[Benson-commit] CVS: benson3/src/network v32_network_client.c,NONE,1.1 v32_network_request.c,NONE,1.

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

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

Added Files:
	v32_network_client.c v32_network_request.c v32_request.h 
Log Message:
Added the v32 changes.

--- NEW FILE: v32_network_client.c ---
/*
 *
 * src/network/v31_network_client.c 
 *
 * Copyright (C) 2002, 2003 Bob Tribit <bt...@ne...>
 */

#include <benson/benson.h>
#include "v32_request.h"
#include "network.h"
#include "config.h"

int bn_ack_v32 (char *destination, int port, char *source,
		char *identity, char *agent, char *subsystem)
{
	int rc;
	bn_req_hdr req_hdr;
	bnet_req_v32 req_pkt;
	bnet_resp_v32 resp_hdr;
	bnet_ack_v32 resp_ack;
	bn_netconnect_ctx connect_ctx;

	safe_strncpy(connect_ctx.destination, destination, DST_MAXSIZE_v32);
	connect_ctx.port = port;

	if((ibn_tcp_connect(&connect_ctx)) == ERROR) {
		fprintf(stderr, "ibn_tcp_connect(%s, %i) failed.\n", destination, port);
		return ERROR;
	}

	if((connect_ctx.input = fdopen(connect_ctx.connfd, "r")) == NULL) {
		perror("bn_acknowledge(): fdopen(r) error");
		return ERROR;
	}
	if((connect_ctx.output = fdopen(connect_ctx.connfd, "w")) == NULL) {
		perror("bn_acknowledge(): fdopen(w) error");
		return ERROR;
	}

	req_hdr.function = htons(BENSON_ACKNOWLEDGE_v32);
	safe_strncpy(req_hdr.benson, PACKAGE, BNH_MAXSIZE_v32);
	safe_strncpy(req_hdr.version, "3.2", VER_MAXSIZE_v32);
	safe_strncpy(req_pkt.inet.destination, destination, DST_MAXSIZE_v32);
	safe_strncpy(req_pkt.inet.agent, source, AGT_MAXSIZE_v32);
	safe_strncpy(req_pkt.data.acknowledge.identity, identity, ID_MAXSIZE_v32);
	safe_strncpy(req_pkt.data.acknowledge.agent, agent, AGT_MAXSIZE_v32);
	safe_strncpy(req_pkt.data.acknowledge.subsystem, subsystem, SUB_MAXSIZE_v32);

	rc = fwrite(&req_hdr, sizeof(bn_req_hdr), 1, connect_ctx.output);
	if(rc < 1) {
		perror("bn_acknowledge(): fwrite() error");
	}	
	rc = fwrite(&req_pkt, sizeof(bnet_req_v32), 1, connect_ctx.output);
	if(rc < 1) {
		perror("bn_acknowledge(): fwrite() error");
	}	
	fflush(connect_ctx.output);

	rc = fread(&resp_hdr, sizeof(bnet_resp_v32), 1, connect_ctx.input);
	if(rc < 1) {
		perror("bn_acknowledge(): fread() error");
	}

	rc = fwrite(&resp_ack, sizeof(bnet_ack_v32), 1, connect_ctx.output);
	if(rc < 1) {
		perror("bn_acknowledge(): fwrite() error");
	}	
	fflush(connect_ctx.output);

	fclose(connect_ctx.output);
	fclose(connect_ctx.input);
	close(connect_ctx.connfd);

	return (int)ntohs(resp_hdr.resp.acknowledge.rc);
}

--- NEW FILE: v32_network_request.c ---
#include "network.h"
#include "v31_request.h"
#include "benson/perl_util.h"

short
process_acknowledge_v32(bnet_req_v32 *req_pkt, SV *server_ref)
{
	char id[ID_MAXSIZE_v31];
	char status[STA_MAXSIZE_v31];
	SV *acknowledge_ref;
	SV *rc;

	safe_strncpy(id, req_pkt->data.acknowledge.identity, ID_MAXSIZE_v32);
	safe_strncpy(status, "acknowledge", STA_MAXSIZE_v32);

	ENTER;
	SAVETMPS;

	bn_require_module("Benson::Alert");
	bn_require_module("Benson::Handlers::Network::Update");
	acknowledge_ref = sv_2mortal(bn_new_object("Benson::Alert", 0));
	bn_set_attribute(acknowledge_ref, "identity", newSVpv(id, 0));
	bn_set_attribute(acknowledge_ref, "status", newSVpv(status, 0));
	bn_set_attribute(acknowledge_ref, "server", SvREFCNT_inc(server_ref));

	rc = sv_2mortal((SV*)bn_call_handler("Benson::Handlers::Network::Update",acknowledge_ref));

	FREETMPS;
	LEAVE;

	return (short)SvIV(rc);
}

int network_request_parser_v32(bn_netaccept_ctx *conn_ctx, bn_req_hdr *request_header)
{
	int rc;
	int function;
	int bytes_read;
	bnet_req_v32 req_pkt;
	PerlInterpreter *request_perl;
	SV *server_ref;
	char config_file[255];

	function = ntohs(request_header->function);

	bytes_read = fread(&req_pkt, sizeof(bnet_req_v32), 1, conn_ctx->input);

	request_perl = bn_perl_initialize(0, NULL, NULL, 1);

	bn_require_module("Benson::Server");
	bn_require_module("Benson::Handlers::Config");
	bn_require_module("Benson::Handlers::Init");
	server_ref = bn_new_object("Benson::Server", 0);

	snprintf(config_file, 255, "%s/etc/benson.conf", BENSON_HOME);
	config_file[255] = '\0';

	bn_set_attribute(server_ref, "ConfigFile", newSVpv(config_file, 0));
	bn_call_handler("Benson::Handlers::Config", server_ref);
	bn_call_handler("Benson::Handlers::Init", server_ref);

	if(function == BENSON_ACKNOWLEDGE_v32) {
		bnet_resp_v32 resp_hdr;
		bnet_ack_v32 resp_ack;

		printf("benson acknowledge received\n");
		rc = process_acknowledge_v32(&req_pkt, server_ref);

		memset(&resp_hdr, 0, sizeof(bnet_resp_v32));
		memset(&resp_ack, 0, sizeof(bnet_ack_v32));

		rc = fwrite(request_header, sizeof(bn_req_hdr), 1, conn_ctx->output);
		rc = fwrite(&resp_hdr, sizeof(bnet_resp_v32), 1, conn_ctx->output);
		fflush(conn_ctx->output);

		rc = fread(&resp_hdr, sizeof(bnet_ack_v32), 1, conn_ctx->input);
	} else {
		printf("unrecognized function\n");
	}
	return GOOD;
}

--- NEW FILE: v32_request.h ---
/*
 *
 * src/network/request.h
 *
 * Copyright (C) 2003 Bob Tribit <bt...@ne...>
 *
 */

#ifndef __v32_request_h
#define __v32_request_h

#define BENSON_TRAP_v32 1
#define BENSON_ALERTLIST_v32 2
#define BENSON_ACKNOWLEDGE_v32 3
#define BENSON_UPDATE_STATUS_v32 4

#define DST_MAXSIZE_v32 50
#define AGT_MAXSIZE_v32 50

typedef struct benson_inet_32 {
	unsigned char destination[DST_MAXSIZE_v32];
	unsigned char agent[AGT_MAXSIZE_v32];
} bn_inet_v32;

#define SEV_MAXSIZE_v32 50
#define SUB_MAXSIZE_v32 50
#define MSG_MAXSIZE_v32 256

typedef struct benson_trap_v32 {
	unsigned char severity[SEV_MAXSIZE_v32];
	unsigned char subsystem[SUB_MAXSIZE_v32];
	unsigned char message[MSG_MAXSIZE_v32];
} bn_trap_v32;

#define STA_MAXSIZE_v32 50
#define UPD_MAXSIZE_v32 50

typedef struct benson_status_v32 {
	unsigned short received;
	unsigned char updated[UPD_MAXSIZE_v32];
	unsigned char status[STA_MAXSIZE_v32];
} bn_status_v32;

#define ID_MAXSIZE_v32 50

typedef struct benson_acknowledge_v32 {
	unsigned char identity[ID_MAXSIZE_v32];
	unsigned char agent[AGT_MAXSIZE_v32];
	unsigned char subsystem[SUB_MAXSIZE_v32];
} bn_acknowledge_v32;

typedef struct benson_update_status_v32 {
	unsigned char identity[ID_MAXSIZE_v32];
	unsigned char status[STA_MAXSIZE_v32];
} bn_update_status_v32;

typedef struct benson_alertlist_v32 {
	unsigned short max_num_alerts;
} bn_alertlist_v32;

#define BNH_MAXSIZE_v32 7
#define VER_MAXSIZE_v32 32

typedef struct benson_request_v32 {
	bn_inet_v32 inet;
	union {
		bn_trap_v32 trap;
		bn_acknowledge_v32 acknowledge;
		bn_alertlist_v32 alertlist;
		bn_update_status_v32 update_status;
	} data;
} bnet_req_v32;

typedef struct benson_alertlist_response_v32 {
	unsigned char identity[ID_MAXSIZE_v32];
	bn_inet_v32 inet;
	bn_trap_v32 trap;
	bn_status_v32 misc;
} bn_alertlist_response_v32;

#define RMSG_MAXSIZE_v32 100

typedef struct benson_trap_response_v32 {
	unsigned char identity[ID_MAXSIZE_v32];
	unsigned char message[RMSG_MAXSIZE_v32];
	unsigned short rc;
} bn_trap_response_v32;

typedef struct benson_acknowledge_response_v32 {
	unsigned short rc;
} bn_acknowledge_response_v32;

typedef struct benson_update_status_response_v32 {
	unsigned short rc;
} bn_update_status_response_v32;

typedef struct benson_response_v32 {
	union {
		unsigned short total_alerts;
		bn_trap_response_v32 trap;
		bn_acknowledge_response_v32 acknowledge;
		bn_update_status_response_v32 update_status;
	} resp;
} bnet_resp_v32;

typedef struct benson_resp_acknowledge_v32 {
	union {
		unsigned short rc;
	} ack;
} bnet_ack_v32;

extern int bn_ack_v32 (char *destination, int port, char *source, char *identity, char *agent, char *subsystem);

#endif /* __v32_request_h */

[Benson-commit] CVS: benson3/src/network v32_network_client.c,NONE,1.1 v32_network_request.c,NONE,1.

[Benson-commit] CVS: benson3/src/network v32_network_client.c,NONE,1.1 v32_network_request.c,NONE,1.1 v32_request.h,NONE,1.1