int vzevt_register(vzevt_handle_t **h)
{
vzevt_handle_t *res_h;
/* allocate handle */
res_h = (vzevt_handle_t *)malloc(sizeof(vzevt_handle_t));
if (!res_h)
return vzevt_err(VZEVT_ERR_NOMEM, "nomem");
bzero(res_h, sizeof(vzevt_handle_t));
/* generate socket name ... */
res_h->sock_name = gen_unx_sockname();
if (!res_h->sock_name) {
free(res_h);
return vzevt_err(VZEVT_ERR_NOMEM, "nomem");
}
res_h->sock = open_sock(res_h->sock_name);
if (res_h->sock == -1) {
close_sock(res_h);
free(res_h);
return -1;
}
*h = res_h;
return VZEVT_ERR_OK;
}
int
main(int argc, char* argv[])
{
int ret = 0;
(void)mls_el_ini();
if (parse_args(argc, argv) < 0) {
goto out;
}
if ((ret = open_sock(_ifname)) != 0) {
goto out;
}
if ((ret = command()) != 0) {
goto out;
}
out:
if (NULL != _cln_ctx) {
#ifdef _USE_UCAST_CONTEXT
mls_net_ucast_close_ctx((struct mls_net_ucast_ctx*)_cln_ctx);
#else /* _USE_UCAST_CONTEXT */
mls_net_mcast_close_ctx(_cln_ctx);
#endif /* _USE_UCAST_CONTEXT */
}
mls_el_fin();
return ret;
}
int process_socket(int sock,int inpipe) {
fd_set fdset; /* selected file descriptors */
int poll,i;
struct timeval tv;
signal(SIGPIPE,SIG_IGN);
signal(SIGUSR1,trap_reset);
listen(sock,5);
tv.tv_sec=0;
tv.tv_usec=0;
poll=0;
runloop=1;
do {
FD_ZERO(&fdset);
FD_SET(inpipe,&fdset);
if (poll==0) {
if (poll_sock(sock,NULL,&fdset) !=0) continue;
} else poll_sock(sock,&tv,&fdset);
/* open any new connections if possible */
open_sock(sock,&fdset);
poll=0;
/* check to see if the root server has sent any data */
if (FD_ISSET(inpipe,&fdset)) {
int size;
size=read(inpipe,mbuf,BUF_SIZE);
if (size==0) break;
write_raw(mbuf,size);
}
/* send the data to the clients */
if (write_sock() !=0) poll=1;
/* read back any data from the clients */
read_sock(&fdset,tmpbuf,BUF_SIZE);
/* decode the buffers here */
} while(runloop);
/* close all the clients down */
for (i=0; i<msgmax; i++) {
if (client[i].sock !=0) close(client[i].sock);
}
close(sock);
return -1;
}
int main(int argc, char *argv[])
{
int i, j, nfn, fd, ret;
u_int mask;
ds_ioctl_arg_t arg;
#if (!defined(__BEOS__) && !defined(__ANTARES__))
major = lookup_dev("pcmcia");
if (major < 0) {
fprintf(stderr, "no pcmcia driver in /proc/devices\n");
exit(EXIT_FAILURE);
}
#endif
for (i = 0; i < MAX_SOCKS; i++) {
fd = open_sock(i);
if (fd < 0) break;
arg.tuple.TupleDataMax = sizeof(arg.tuple_parse.data);
arg.tuple.Attributes = TUPLE_RETURN_COMMON;
arg.tuple.DesiredTuple = CISTPL_LONGLINK_MFC;
arg.tuple.TupleOffset = 0;
if (ioctl(fd, DS_GET_FIRST_TUPLE, &arg) == 0) {
ioctl(fd, DS_GET_TUPLE_DATA, &arg);
ioctl(fd, DS_PARSE_TUPLE, &arg);
nfn = arg.tuple_parse.parse.longlink_mfc.nfn;
} else {
nfn = 1;
arg.tuple.DesiredTuple = CISTPL_DEVICE;
ret = ioctl(fd, DS_GET_FIRST_TUPLE, &arg);
if (ret != 0) {
if (errno != ENODEV) perror("ioctl()");
continue;
}
}
arg.tuple.DesiredTuple = CISTPL_CONFIG;
for (j = 0; j < nfn; j++) {
printf("Socket %d function %d:\n", i, j);
if (ioctl(fd, DS_GET_NEXT_TUPLE, &arg) != 0) {
printf(" no config tuple: %s\n\n", strerror(errno));
continue;
}
ioctl(fd, DS_GET_TUPLE_DATA, &arg);
ioctl(fd, DS_PARSE_TUPLE, &arg);
printf(" Config register base = %#4.4x, mask = %#4.4x\n",
arg.tuple_parse.parse.config.base,
arg.tuple_parse.parse.config.rmask[0]);
mask = arg.tuple_parse.parse.config.rmask[0];
dump_all(fd, j, (nfn > 1), mask);
}
}
return 0;
}
struct server *create_server(char *host, unsigned short port, struct frame_buffers *fbs, char *static_root, char *auth, char *ssl_cert_file, char *ssl_key_file) {
struct server *s = malloc(sizeof(struct server));
size_t stream_info_buf_size;
memset(s->clients, 0, sizeof(s->clients));
s->sock6 = open_sock(host, port, AF_INET6, SOCK_STREAM);
s->sock4 = open_sock(host, port, AF_INET, SOCK_STREAM);
if (s->sock4 < 0 && s->sock6 < 0) {
panic("Could not bind to socket.");
}
stream_info_buf_size = sizeof(HTTP_STREAM_INFO_TEMPLATE) + 64; // Should be enough room for the data
s->stream_info = malloc(stream_info_buf_size);
snprintf(s->stream_info,
stream_info_buf_size,
HTTP_STREAM_INFO_TEMPLATE,
(int) fbs->count,
fbs->buffers[0].vd->width,
fbs->buffers[0].vd->height
);
s->auth = NULL;
if (strlen(auth)) {
s->auth = base64_encode((unsigned char *) auth);
}
s->static_root = strdup(static_root);
s->ssl_ctx = NULL;
if (strlen(ssl_cert_file) && strlen(ssl_key_file)) {
s->ssl_ctx = ssl_create_ctx();
ssl_load_certs(s->ssl_ctx, ssl_cert_file, ssl_key_file);
}
else if (strlen(auth)) {
log_itf(LOG_WARNING, "You are password protecting your streams, but not using encryption.\nAnyone can see your password!");
}
return s;
}
int main(int argc, char **argv)
{
parse_opt(argc,argv);
open_sock();
if ( arg_dumpsockets ) dump_sockets();
if ( arg_dumpnet ) dump_net();
return 0;
}
int main(int argc, char** argv){
int rx_mode = DMA_MODE,tx_mode = DMA_MODE;
int recv_mode = RECEIVE_MODE;
char ifname[10] = {0}, *bindstr;
char rxif[128], *pif;
int numproc = 4, i = 0;
lib_init();
for(i=1; i<argc; i++){
if(!strncmp(argv[i], "-r", 2)){
sprintf(rxif, "%s", argv[i]+2);
}
}
pif = rxif;
sscanf(pif, "eth%d", &rx_port);
sprintf(ifname, "eth%d", rx_port);
sockfd = open_sock(ifname, rx_mode, tx_mode, recv_mode, numproc);
if(sockfd < 0)
{
printf("open_sock %s failure!\n",ifname);
}
else
{
printf("open_sock %s success!\n",ifname);
}
bindstr = "1:2:3:4";
set_sockopt(sockfd,SET_BINDING,bindstr);
start_proc(sockfd);
printf("start now...\n");
while(1)
{
tIfStat rxstat;
get_sockopt(sockfd, GET_IF_RXTX_STAT, (int *)&rxstat);
//system("clear");
//write_in_file(rxstat.rx_bps, rxstat.rx_pps);
db_insert(rxstat.rx_bps*8+rxstat.rx_pps*PAD_LEN*8, rxstat.rx_pps);
printf("eth%d %lu bps, %u pps.\n", sockfd,
rxstat.rx_bps*8+rxstat.rx_pps*PAD_LEN*8, rxstat.rx_pps);
sleep(10);
//system("clear");
}
close_sock(sockfd);
return 0;
}
static void open_card_and_sock(struct sstate *ss, char *dev, int port, int chan)
{
printf("Opening card %s\n", dev);
card_open(ss, dev);
printf("Setting chan %d\n", chan);
if (card_set_chan(ss, chan) == -1)
err(1, "card_set_chan()");
printf("Opening sock port %d\n", port);
open_sock(ss, port);
printf("Serving %s chan %d on port %d\n", dev, chan, port);
}
int process_env(char *envp[])
{
int count = 0;
int socket;
struct Nagios_Env *base = NULL;
struct Nagios_Env *ptr = NULL;
while (1) {
if (socket_status == CLOSE) {
socket = open_sock(serverip);
}
if (envp[count] == NULL) {
break;
}
parse_env(envp[count], &base);
count++;
}
print_list(socket, base);
return (0);
}
static void start_daemon(int lockfd)
{
int maxfd, pid, pipefd, ret;
struct timeval tv;
fd_set rfds;
conn_t *tmp, *tmpnext;
us_serialize(SERIALIZE_INIT);
if ((pid = fork()) < 0)
fatal_with_errno(EXIT_FAILURE, "Unable to enter background");
if (pid != 0) { /* parent */
/* wait for child to set up the listener */
us_serialize(SERIALIZE_WAIT);
return;
}
/* child */
close(0);
close(1);
close(2);
/* make fds 0-2 point somewhere defined */
if (open("/dev/null", O_RDWR) != 0)
fatal_with_errno(EXIT_FAILURE, "open /dev/null");
if (dup(0) == -1)
fatal_with_errno(EXIT_FAILURE, "dup");
if (dup(0) == -1)
fatal_with_errno(EXIT_FAILURE, "dup");
pipefd = open_sock();
if (verbose)
upslogx(LOG_INFO, "Timer daemon started");
/* release the parent */
us_serialize(SERIALIZE_SET);
/* drop the lock now that the background is running */
unlink(lockfn);
close(lockfd);
/* now watch for activity */
for (;;) {
/* wait at most 1s so we can check our timers regularly */
tv.tv_sec = 1;
tv.tv_usec = 0;
FD_ZERO(&rfds);
FD_SET(pipefd, &rfds);
maxfd = pipefd;
for (tmp = connhead; tmp != NULL; tmp = tmp->next) {
FD_SET(tmp->fd, &rfds);
if (tmp->fd > maxfd)
maxfd = tmp->fd;
}
ret = select(maxfd + 1, &rfds, NULL, NULL, &tv);
if (ret > 0) {
if (FD_ISSET(pipefd, &rfds))
conn_add(pipefd);
tmp = connhead;
while (tmp) {
tmpnext = tmp->next;
if (FD_ISSET(tmp->fd, &rfds)) {
if (sock_read(tmp) < 0) {
close(tmp->fd);
conn_del(tmp);
}
}
tmp = tmpnext;
}
}
checktimers();
}
}
int send_data(nebstruct_service_check_data *data){
char temp_buffer[1024];
char *message;
int socket;
int message_length = 1024;
char cmd[1024];
time_t t;
if (socket_status == CLOSE) {
socket = open_sock();
if (socket == -1) {
write_to_all_logs("modpnpsender: Arg! Socket is -1",NSLOG_INFO_MESSAGE);
return (-1);
}
}
if (!(message = (char *) malloc(message_length))) {
snprintf(temp_buffer,sizeof(temp_buffer)-1,"modpnpsender: cannot allocate memory for message. Aborting...\n");
temp_buffer[sizeof(temp_buffer)-1]='\x0';
write_to_all_logs(temp_buffer,NSLOG_INFO_MESSAGE);
return (-1);
}
bzero((void *)message, message_length);
strcat(message,"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n");
strcat(message,"<NAGIOS>\n<NAGIOS_DATATYPE>serviceperfdata</NAGIOS_DATATYPE>\n");
strcat(message,"<NAGIOS_HOSTNAME>");
strcat(message,data->host_name);
strcat(message,"</NAGIOS_HOSTNAME>\n");
strcat(message,"<NAGIOS_SERVICEDESC>");
strcat(message,data->service_description);
strcat(message,"</NAGIOS_SERVICEDESC>\n");
strcat(message,"<NAGIOS_SERVICEPERFDATA>");
strcat(message,data->perf_data);
strcat(message,"</NAGIOS_SERVICEPERFDATA>\n");
strcat(message,"<NAGIOS_SERVICECHECKCOMMAND>");
if (data->command_name != NULL) {
strcat(message,data->command_name);
}
strcat(message,"</NAGIOS_SERVICECHECKCOMMAND>\n");
strcat(message,"<NAGIOS_SERVICECHECKCOMMAND_ARGS>");
if (data->command_args != NULL) strcat(message,data->command_args);
strcat(message,"</NAGIOS_SERVICECHECKCOMMAND>\n");
strcat(message,"<NAGIOS_SERVICECHECKCOMMAND_LINE>");
if (data->command_line != NULL) strcat(message,data->command_line);
strcat(message,"</NAGIOS_SERVICECHECKCOMMAND>\n");
strcat(message,"<NAGIOS_SERVICEOUTPUT>");
if (data->output != NULL) strcat(message,data->output);
strcat(message,"</NAGIOS_SERVICEOUTPUT>\n");
time(&t);
snprintf(temp_buffer, sizeof(temp_buffer)-1,"%ld",t);
temp_buffer[sizeof(temp_buffer)-1]='\x0';
strcat(message,"<NAGIOS_TIMET>");
strcat(message, temp_buffer);
strcat(message,"</NAGIOS_TIMET>\n");
bzero((void *)temp_buffer,sizeof(temp_buffer)-1);
strcat(message,"</NAGIOS>\n");
if(send(socket, message, strlen(message), 0) == -1) {
snprintf(temp_buffer,sizeof(temp_buffer)-1,"modpnpsender: error while sending message to server. - %s\n",strerror(errno));
temp_buffer[sizeof(temp_buffer)-1]='\x0';
write_to_all_logs(temp_buffer,NSLOG_INFO_MESSAGE);
}
close (socket);
socket_status = CLOSE;
snprintf(temp_buffer,sizeof(temp_buffer)-1,"modpnpsender: Sending perfdata for %s / %s with perfdata %s",data->host_name,data->service_description,data->perf_data);
temp_buffer[sizeof(temp_buffer)-1]='\x0';
write_to_all_logs(temp_buffer,NSLOG_INFO_MESSAGE);
return 0;
}
