[Benson-commit] CVS: benson3/src/network Makefile.in,1.6,1.7 v31_network_client.c,1.1,1.2

[Bob T. <bt...@us...>]

Update of /cvsroot/benson/benson3/src/network
In directory sc8-pr-cvs1:/tmp/cvs-serv24239/network

Modified Files:
	Makefile.in v31_network_client.c 
Log Message:
Reworked the network code to make a little more sense

Index: Makefile.in
===================================================================
RCS file: /cvsroot/benson/benson3/src/network/Makefile.in,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -r1.6 -r1.7
*** Makefile.in	29 Sep 2003 18:04:10 -0000	1.6
--- Makefile.in	30 Sep 2003 03:55:19 -0000	1.7
***************
*** 19,25 ****
  	$(CC) $(CFLAGS) $(CPPFLAGS) -c $<
  
! all: libnetwork.a
  
  $(LIBNETWORK): ../../config.h
  
  libnetwork.a: $(LIBNETWORK) v31_network_request.o
--- 19,32 ----
  	$(CC) $(CFLAGS) $(CPPFLAGS) -c $<
  
! all: libnetwork.a libnetclient.so
  
  $(LIBNETWORK): ../../config.h
+ 
+ libnetclient.a: v31_network_client.o
+ 	$(AR) rv $@ v31_network_client.o
+ 	$(RANLIB) $@
+ 
+ libnetclient.so: libnetclient.a
+ 	$(CC) -shared -o libnetclient.so v31_network_client.o $(LD_FLAGS) $(LIBS)
  
  libnetwork.a: $(LIBNETWORK) v31_network_request.o

Index: v31_network_client.c
===================================================================
RCS file: /cvsroot/benson/benson3/src/network/v31_network_client.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** v31_network_client.c	12 May 2003 03:29:44 -0000	1.1
--- v31_network_client.c	30 Sep 2003 03:55:19 -0000	1.2
***************
*** 0 ****
--- 1,269 ----
+ /*
+  *
+  * src/network/v31_network_client.c 
+  *
+  * Copyright (C) 2002, 2003 Bob Tribit <bt...@ne...>
+  */
+ 
+ #include <benson/benson.h>
+ #include "v31_request.h"
+ #include "network.h"
+ #include "config.h"
+ 
+ struct benson_alertlist_response *bn_alertlist (char *destination, int port, char *source, int *buffer_size)
+ {
+ 	int ctr;
+ 	int rc = 0;
+ 	bnet_req req_pkt;
+ 	bnet_resp resp_hdr;
+ 	bnet_ack resp_ack;
+ 	struct benson_alertlist_response *alertlist_ptr;
+ 	unsigned short total_alerts;
+ 	unsigned int alertlist_size;
+ 	unsigned int total_num_alerts = 0;
+ 	int connfd;
+ 	FILE *sockout, *sockin;
+ 
+ 
+ 	/* Open up a connection */
+ 	if((connfd = ibn_tcp_connect(destination, port)) == ERROR) {
+ 		fprintf(stderr, "ibn_tcp_connect(%s, %i) failed.\n", destination, port);
+ 		return NULL;
+ 	}
+ 
+ 	/* Open up the socket descriptor as file descriptors */
+ 	if((sockin = fdopen(connfd, "r")) == NULL) {
+ 		perror("bn_alertlist(): fdopen(r) error");
+ 		return NULL;
+ 	}
+ 	if((sockout = fdopen(connfd, "w")) == NULL) {
+ 		perror("bn_alertlist(): fdopen(w) error");
+ 		return NULL;
+ 	}
+ 
+ 	/* Build alertlist request */
+ 	req_pkt.function = htons(BENSON_ALERTLIST_v31);
+ 	safe_insert(req_pkt.benson, PACKAGE, BNH_MAXSIZE_v31);
+ 	safe_insert(req_pkt.version, VERSION, VER_MAXSIZE_v31);
+ 	safe_insert(req_pkt.inet.destination, destination, DST_MAXSIZE_v31);
+ 	safe_insert(req_pkt.inet.agent, source, AGT_MAXSIZE_v31);
+ 
+ 	/* Write the data, check for errors, and flush the buffer */
+ 	rc = fwrite(&req_pkt, sizeof(bnet_req), 1, sockout);
+ 	if(rc < 1) {
+ 		perror("bn_alertlist(): fwrite() failure");
+ 	}
+ 	fflush(sockout);
+ 
+ 	/* Read the response from the server, atleast the header portion, more should be coming. */
+ 	rc = fread(&resp_hdr, sizeof(bnet_resp), 1, sockin);
+ 	if(rc < 1) {
+ 		perror("bn_alertlist(): fread() failure");
+ 	}
+ 
+ 	/* Get the total number of alerts coming in off the wire */
+ 	total_num_alerts = ntohs(resp_hdr.resp.total_alerts);
+ 
+ 	/* Allocate some memory for the alertlist that will we read soon enough */
+ 	if((alertlist_ptr = (struct benson_alertlist_response *) malloc(sizeof(struct benson_alertlist_response) * total_num_alerts)) == NULL) {
+ 		perror("bn_alertlist(): malloc() failed");
+ 		return NULL;
+ 	}
+ 
+ 	for(ctr=0; ctr < total_num_alerts; ctr++) {
+ 		rc = fread(&alertlist_ptr[ctr], sizeof(struct benson_alertlist_response), 1, sockin);
+ 		if(rc < 1) {
+ 			perror("bn_alertlist(): fread() failure");
+ 			free(alertlist_ptr);
+ 			return NULL;
+ 		}
+ 	}
+ 	*buffer_size = sizeof(struct benson_alertlist_response) * total_num_alerts;
+ 
+ 	rc = fwrite(&resp_ack, sizeof(bnet_ack), 1, sockout);
+ 	if(rc < 1) {
+ 		perror("bn_alertlist(): fwrite() error");
+ 	}	
+ 	fflush(sockout);
+ 
+ 	fclose(sockout);
+ 	fclose(sockin);
+ 	close(connfd);
+ 	return alertlist_ptr;
+ }
+ 
+ int bn_send_trap (char *destination, int port, char *source,
+ 		char *severity, char *subsystem, char *message)
+ {
+ 	int connfd;
+ 	FILE *sockin, *sockout;
+ 	int rc = 0;
+ 	bnet_req req_pkt;
+ 	bnet_resp resp_hdr;
+ 	bnet_ack resp_ack;
+ 
+ 	if((connfd = ibn_tcp_connect(destination, port)) == ERROR) {
+ 		fprintf(stderr, "ibn_tcp_connect(%s, %i) failed.\n", destination, port);
+ 		return ERROR;
+ 	}
+ 
+ 	if((sockin = fdopen(connfd, "r")) == NULL) {
+ 		perror("bn_send_trap(): fdopen(r) error");
+ 		return ERROR;
+ 	}
+ 	if((sockout = fdopen(connfd, "w")) == NULL) {
+ 		perror("bn_send_trap(): fdopen(w) error");
+ 		return ERROR;
+ 	}
+ 
+ 	req_pkt.function = htons(BENSON_TRAP_v31);
+ 	safe_insert(req_pkt.benson, PACKAGE, BNH_MAXSIZE_v31);
+ 	safe_insert(req_pkt.version, VERSION, VER_MAXSIZE_v31);
+ 	safe_insert(req_pkt.inet.destination, destination, DST_MAXSIZE_v31);
+ 	safe_insert(req_pkt.inet.agent, source, AGT_MAXSIZE_v31);
+ 	safe_insert(req_pkt.data.trap.severity, severity, SEV_MAXSIZE_v31);
+ 	safe_insert(req_pkt.data.trap.subsystem, subsystem, SUB_MAXSIZE_v31);
+ 	safe_insert(req_pkt.data.trap.message, message, MSG_MAXSIZE_v31);
+ 
+ 	rc = fwrite(&req_pkt, sizeof(bnet_req), 1, sockout);
+ 	if(ferror(sockout)) {
+ 		perror("bn_send_trap(): fwrite() error");
+ 	}
+ 
+ 	rc = fflush(sockout);
+ 	if(feof(sockout) || ferror(sockout) || (rc != 0)) {
+ 		perror("bn_send_trap(): fflush() error");
+ 		clearerr(sockout);
+ 	}
+ 
+ 	rc = fread(&resp_hdr, sizeof(bnet_resp), 1, sockin);
+ 	if(ferror(sockin)) {
+ 		perror("bn_send_trap(): fread() error");
+ 	}
+ 
+ 	rc = fwrite(&resp_ack, sizeof(bnet_ack), 1, sockout);
+ 	if(ferror(sockout)) {
+ 		perror("bn_send_trap(): fwrite() error");
+ 	}	
+ 	fflush(sockout);
+ 
+ 	fclose(sockout);
+ 	fclose(sockin);
+ 	close(connfd);
+ 
+ //	fprintf(stderr, "bn_send_trap identity = %s\n", resp_hdr.resp.trap.identity);
+ 
+ 	return (short)ntohs(resp_hdr.resp.trap.rc);
+ }
+ 
+ int bn_acknowledge (char *destination, int port, char *source,
+ 		char *identity)
+ {
+ 	int connfd, ofcmode, rc;
+ 	FILE *sockin, *sockout;
+ 	bnet_req req_pkt;
+ 	bnet_resp resp_hdr;
+ 	bnet_ack resp_ack;
+ 
+ 	if((connfd = ibn_tcp_connect(destination, port)) == ERROR) {
+ 		fprintf(stderr, "ibn_tcp_connect(%s, %i) failed.\n", destination, port);
+ 		return ERROR;
+ 	}
+ 
+ 	if((sockin = fdopen(connfd, "r")) == NULL) {
+ 		perror("bn_acknowledge(): fdopen(r) error");
+ 		return ERROR;
+ 	}
+ 	if((sockout = fdopen(connfd, "w")) == NULL) {
+ 		perror("bn_acknowledge(): fdopen(w) error");
+ 		return ERROR;
+ 	}
+ 
+ 	req_pkt.function = htons(BENSON_ACKNOWLEDGE_v31);
+ 	safe_insert(req_pkt.benson, PACKAGE, BNH_MAXSIZE_v31);
+ 	safe_insert(req_pkt.version, VERSION, VER_MAXSIZE_v31);
+ 	safe_insert(req_pkt.inet.destination, destination, DST_MAXSIZE_v31);
+ 	safe_insert(req_pkt.inet.agent, source, AGT_MAXSIZE_v31);
+ 	safe_insert(req_pkt.data.acknowledge.identity, identity, ID_MAXSIZE_v31);
+ 
+ 	rc = fwrite(&req_pkt, sizeof(bnet_req), 1, sockout);
+ 	if(rc < 1) {
+ 		perror("bn_acknowledge(): fwrite() error");
+ 	}	
+ 	fflush(sockout);
+ 
+ 	rc = fread(&resp_hdr, sizeof(bnet_resp), 1, sockin);
+ 	if(rc < 1) {
+ 		perror("bn_acknowledge(): fread() error");
+ 	}
+ 
+ 	rc = fwrite(&resp_ack, sizeof(bnet_ack), 1, sockout);
+ 	if(rc < 1) {
+ 		perror("bn_acknowledge(): fwrite() error");
+ 	}	
+ 	fflush(sockout);
+ 
+ 	fclose(sockout);
+ 	fclose(sockin);
+ 	close(connfd);
+ 
+ 	return (int)ntohs(resp_hdr.resp.acknowledge.rc);
+ }
+ 
+ int bn_update_status (char *destination, int port, char *source,
+ 		char *identity, char *status)
+ {
+ 	int connfd, ofcmode, rc;
+ 	FILE *sockin, *sockout;
+ 	bnet_req req_pkt;
+ 	bnet_resp resp_hdr;
+ 	bnet_ack resp_ack;
+ 
+ 	if((connfd = ibn_tcp_connect(destination, port)) == ERROR) {
+ 		fprintf(stderr, "ibn_tcp_connect(%s, %i) failed.\n", destination, port);
+ 		return ERROR;
+ 	}
+ 
+ 	if((sockin = fdopen(connfd, "r")) == NULL) {
+ 		perror("bn_update_status(): fdopen(r) error");
+ 		return ERROR;
+ 	}
+ 	if((sockout = fdopen(connfd, "w")) == NULL) {
+ 		perror("bn_update_status(): fdopen(w) error");
+ 		return ERROR;
+ 	}
+ 
+ 	req_pkt.function = htons(BENSON_UPDATE_STATUS_v31);
+ 	safe_insert(req_pkt.benson, PACKAGE, BNH_MAXSIZE_v31);
+ 	safe_insert(req_pkt.version, VERSION, VER_MAXSIZE_v31);
+ 	safe_insert(req_pkt.inet.destination, destination, DST_MAXSIZE_v31);
+ 	safe_insert(req_pkt.inet.agent, source, AGT_MAXSIZE_v31);
+ 	safe_insert(req_pkt.data.update_status.identity, identity, ID_MAXSIZE_v31);
+ 	safe_insert(req_pkt.data.update_status.status, status, STA_MAXSIZE_v31);
+ 
+ 	printf("%s %s\n", identity, status);
+ 
+ 	rc = fwrite(&req_pkt, sizeof(bnet_req), 1, sockout);
+ 	if(rc < 1) {
+ 		perror("bn_update_status(): fwrite() error");
+ 	}	
+ 	fflush(sockout);
+ 
+ 	rc = fread(&resp_hdr, sizeof(bnet_resp), 1, sockin);
+ 	if(rc < 1) {
+ 		perror("bn_update_status(): fread() error");
+ 	}
+ 
+ 	rc = fwrite(&resp_ack, sizeof(bnet_ack), 1, sockout);
+ 	if(rc < 1) {
+ 		perror("bn_update_status(): fwrite() error");
+ 	}	
+ 	fflush(sockout);
+ 
+ 	fclose(sockout);
+ 	fclose(sockin);
+ 	close(connfd);
+ 
+ 	return (int)ntohs(resp_hdr.resp.update_status.rc);
+ }
+