2 * Copyright (c) 1998,1999 Martin Husemann. All rights reserved.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the author nor the names of any co-contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 * 4. Altered versions must be plainly marked as such, and must not be
17 * misrepresented as being the original software and/or documentation.
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 *---------------------------------------------------------------------------
33 * i4b daemon - network monitor client
34 * -----------------------------------
36 * $Id: main.c,v 1.35 2000/08/24 11:48:57 hm Exp $
38 * $FreeBSD: src/usr.sbin/i4b/isdnmonitor/main.c,v 1.7.2.1 2001/08/01 17:45:06 obrien Exp $
39 * $DragonFly: src/usr.sbin/i4b/isdnmonitor/main.c,v 1.4 2004/02/10 02:59:42 rob Exp $
41 * last edit-date: [Mon Dec 13 21:52:11 1999]
43 *---------------------------------------------------------------------------*/
56 #include <sys/types.h>
58 #include <sys/socket.h>
59 #include <sys/ioctl.h>
61 #include <netinet/in.h>
62 #include <arpa/inet.h>
67 int getopt(int nargc, char * const nargv[], const char *ostr);
68 #define close(f) closesocket(f)
69 #define sleep(s) Sleep(s*1000)
70 #define vsnprintf _vsnprintf
78 #include "monprivate.h"
82 #define AF_LOCAL AF_UNIX
92 * Local function prototypes
94 static int connect_local(char *sockpath);
95 static int connect_remote(char *host, int portno);
98 static void handle_input();
99 static void print_menu();
100 static void print_logevent(time_t tstamp, int prio, char * what, char * msg);
101 static void print_charge(time_t tstamp, int controller, int channel, int units, int estimated);
102 static void print_connect(time_t tstamp, int dir, int controller, int channel, char * cfgname, char * devname, char * remphone, char * locphone);
103 static void print_disconnect(time_t tstamp, int controller, int channel);
104 static void print_updown(time_t tstamp, int contoller, int channel, int isup);
105 static void handle_event(u_int8_t *msg, int len);
107 static void dump_event(u_int8_t *msg, int len, int readflag);
110 static ssize_t sock_read(int fd, void *buf, size_t nbytes);
111 static ssize_t sock_write(int fd, void *buf, size_t nbytes);
113 static void mprintf(char *fmt, ...);
118 static int debug = 0;
119 #define DBG_DUMPALL 0x01
120 #define DBG_PSEND 0x02
122 static int monsock = -1;
123 static int state = ST_INIT;
124 static int sub_state = 0;
125 static int sub_state_count = 0;
127 static int isdn_major = 0;
128 static int isdn_minor = 0;
129 static u_int32_t rights = 0;
131 static char *logfilename = NULL;
132 static FILE *lfp = NULL;
134 /*---------------------------------------------------------------------------
135 * Display usage and exit
136 *---------------------------------------------------------------------------*/
140 fprintf(stderr, "\n");
141 fprintf(stderr, "isdnmonitor - version %02d.%02d.%d, %s %s (protocol %02d.%02d)\n", VERSION, REL, STEP, __DATE__, __TIME__, MPROT_VERSION, MPROT_REL);
143 fprintf(stderr, " usage: isdnmonitor [-c] [-d val] [-f name] [-h host] [-p port]\n");
145 fprintf(stderr, " usage: isdnmonitor [-c] [-d val] [-f name] [-h host] [-l path] [-p port]\n");
147 fprintf(stderr, " -c switch to curses fullscreen output\n");
148 fprintf(stderr, " -d <val> debug flags (see source ...)\n");
149 fprintf(stderr, " -dn no debug output on fullscreen display\n");
150 fprintf(stderr, " -f <name> filename to log output to\n");
151 fprintf(stderr, " -h <host> hostname/address to connect to\n");
153 fprintf(stderr, " -l <path> pathname to local domain socket to connect to\n");
155 fprintf(stderr, " -p <port> portnumber to use to connect to remote host\n");
159 /*---------------------------------------------------------------------------
160 * Parse command line, startup monitor client
161 *---------------------------------------------------------------------------*/
162 int main(int argc, char **argv)
168 WSAStartup(MAKEWORD(2, 0), &wsCaps);
171 portno = DEF_MONPORT;
175 while((i = getopt(argc, argv, "cd:f:h:p:l:")) != -1)
177 while((i = getopt(argc, argv, "cd:f:h:p:")) != -1)
192 if((sscanf(optarg, "%i", &debug)) != 1)
197 logfilename = optarg;
208 if((sscanf(optarg, "%i", &portno)) != 1)
218 if(hostname && sockpath)
220 fprintf(stderr, "Error: can not use local socket path on remote machine\n"
221 "conflicting options -h and -l!\n");
227 monsock = connect_local(sockpath);
235 monsock = connect_remote(hostname, portno);
244 fprintf(stderr, "Could not connect to i4b isdn daemon.\n");
248 if(logfilename != NULL)
250 if((lfp = fopen(logfilename, "w")) == NULL)
252 fprintf(stderr, "could not open logfile [%s], %s\n", logfilename, strerror(errno));
258 signal(SIGPIPE, SIG_IGN);
268 /*---------------------------------------------------------------------------
269 * Connect via tcp/ip.
270 * Return socket if successfull, -1 on error.
271 ---------------------------------------------------------------------------*/
273 connect_remote(char *host, int portno)
275 struct sockaddr_in sa;
279 h = gethostbyname(host);
283 fprintf(stderr, "could not resolve hostname '%s'\n", host);
287 remotesockfd = socket(AF_INET, SOCK_STREAM, 0);
289 if(remotesockfd == -1)
291 fprintf(stderr, "could not create remote monitor socket: %s\n", strerror(errno));
295 memset(&sa, 0, sizeof(sa));
298 sa.sin_len = sizeof(sa);
300 sa.sin_family = AF_INET;
301 sa.sin_port = htons(portno);
303 memcpy(&sa.sin_addr.s_addr, h->h_addr_list[0], sizeof(sa.sin_addr.s_addr));
305 if(connect(remotesockfd, (struct sockaddr *)&sa, sizeof(sa)) == -1)
307 fprintf(stderr, "could not connect remote monitor: %s\n", strerror(errno));
315 /*---------------------------------------------------------------------------
317 * Return socket on success, -1 on failure.
318 *---------------------------------------------------------------------------*/
320 connect_local(char *sockpath)
323 struct sockaddr_un sa;
325 /* check path length */
326 if(strlen(sockpath) >= sizeof(sa.sun_path))
328 fprintf(stderr, "pathname to long for local socket: %s\n",
333 /* create and setup socket */
334 s = socket(AF_LOCAL, SOCK_STREAM, 0);
338 fprintf(stderr, "could not create local monitor socket:%s\n", strerror(errno));
342 memset(&sa, 0, sizeof(sa));
344 sa.sun_len = sizeof(sa);
345 sa.sun_family = AF_LOCAL;
346 strcpy(sa.sun_path, sockpath);
348 if(connect(s, (struct sockaddr *)&sa, sizeof(sa)))
350 fprintf(stderr, "could not connect local monitor socket [%s]: %s\n", sockpath, strerror(errno));
357 /*---------------------------------------------------------------------------*
358 * data from keyboard available, read and process it
359 *---------------------------------------------------------------------------*/
368 case 0x0c: /* control L */
380 /*---------------------------------------------------------------------------
382 *---------------------------------------------------------------------------*/
393 FD_SET(fileno(stdin), &rd);
394 FD_SET(monsock, &rd);
396 select(monsock+1, &rd, &wr, &ex, NULL);
398 if(FD_ISSET(fileno(stdin), &rd))
401 if(fullscreen && curses_ready)
411 if(FD_ISSET(monsock, &rd))
416 /* Network transfer may deliver two or more packets concatenated.
417 * Peek at the header and read only one event at a time... */
419 bytes = recv(monsock, buf, I4B_MON_EVNT_HDR, MSG_PEEK);
433 mprintf("remote isdnd has closed our connection\n");
438 fprintf(stderr, "recv error: %s\n", strerror(errno));
443 if (bytes < I4B_MON_EVNT_HDR)
444 continue; /* errh? something must be wrong... */
446 bytes = I4B_GET_2B(buf, I4B_MON_EVNT_LEN);
448 if(bytes >= sizeof(buf))
450 fprintf(stderr, "mloop: socket recv buffer overflow %d!\n", bytes);
454 /* now we know the size, it fits, so lets read it! */
456 ret = sock_read(monsock, buf, bytes);
465 mprintf("remote isdnd has closed our connection\n");
470 mprintf("error reading from isdnd: %s", strerror(errno));
474 if(debug & DBG_DUMPALL)
475 dump_event(buf, ret, 1);
477 handle_event(buf, ret);
484 * Dump a complete event packet.
486 static void dump_event(u_int8_t *msg, int len, int read)
491 mprintf("read from socket:");
493 mprintf("write to socket:");
495 for(i = 0; i < len; i++)
498 mprintf("\n%02d: ", i);
499 mprintf("0x%02x %c ", msg[i], isprint(msg[i]) ? msg[i] : '.');
506 print_logevent(time_t tstamp, int prio, char * what, char * msg)
509 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
510 mprintf("log: %s prio %d what=%s msg=%s\n", buf, prio, what, msg);
515 if((!debug_noscreen) || (debug_noscreen && (((strcmp(what, "DBG"))) != 0)))
518 * FreeBSD-current integrated ncurses. Since then it is no longer possible
519 * to write to the last column in the logfilewindow without causing an
520 * automatic newline to occur resulting in a blank line in that window.
523 #include <osreldate.h>
525 #if defined(__DragonFly__)
526 #warning "FreeBSD ncurses is buggy: write to last column = auto newline!"
527 wprintw(lower_w, "%s %s %-.*s\n", buf, what,
528 COLS-((strlen(buf))+(strlen(what))+3), msg);
530 wprintw(lower_w, "%s %s %-.*s\n", buf, what,
531 (int)(COLS-((strlen(buf))+(strlen(what))+2)), msg);
540 print_charge(time_t tstamp, int controller, int channel, int units, int estimated)
543 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
544 mprintf("%s: controller %d, channel %d, charge = %d%s\n",
545 buf, controller, channel, units, estimated ? " (estimated)" : "");
550 display_ccharge(CHPOS(controller, channel), units);
552 display_charge(CHPOS(controller, channel), units);
558 * Print a connect event.
559 * A real monitor would allocate state info for "channel" on this
562 static void print_connect(
563 time_t tstamp, /* server time of event */
564 int outgoing, /* 0 = incoming, 1 = outgoing */
565 int controller, /* controller number */
566 int channel, /* channel no, used to identify this connection until disconnect */
567 char * cfgname, /* name of config entry/connection */
568 char * devname, /* device used (e.g. isp0) */
569 char * remphone, /* phone no of remote side */
570 char * locphone) /* local phone no */
575 remstate[controller].ch1state = 1;
577 remstate[controller].ch2state = 1;
579 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
582 mprintf("%s: calling out to '%s' [from msn: '%s']",
583 buf, remphone, locphone);
585 mprintf("%s: incoming call from '%s' [to msn: '%s']",
586 buf, remphone, locphone);
587 mprintf(", controller %d, channel %d, config '%s' on device '%s'\n",
588 controller, channel, cfgname, devname);
592 display_connect(CHPOS(controller, channel), outgoing, cfgname, remphone, devname);
597 * Print a disconnect event.
598 * A real monitor could free the "per connection" state
599 * for this channel now
602 print_disconnect(time_t tstamp, int controller, int channel)
607 remstate[controller].ch1state = 0;
609 remstate[controller].ch2state = 0;
611 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
613 mprintf("%s: controller %d, channel %d disconnected\n",
614 buf, controller, channel);
618 display_disconnect(CHPOS(controller, channel));
623 * Print an up- or down event
626 print_updown(time_t tstamp, int controller, int channel, int isup)
629 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
630 mprintf("%s: channel %d is %s\n",
631 buf, channel, isup ? "up" : "down");
635 * Print l1 / l2 status
638 print_l12stat(time_t tstamp, int controller, int layer, int state)
641 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
643 mprintf("%s: layer %d change on controller %d: %s\n",
644 buf, layer, controller, state ? "up" : "down");
647 display_l12stat(controller, layer, state);
655 print_tei(time_t tstamp, int controller, int tei)
658 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
660 mprintf("%s: controller %d, TEI is %d\n",
661 buf, controller, tei);
665 display_tei(controller, tei);
670 * Print accounting information
673 print_acct(time_t tstamp, int controller, int channel, int obytes, int obps,
674 int ibytes, int ibps)
677 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
679 mprintf("%s: controller %d, channel %d: %d obytes, %d obps, %d ibytes, %d ibps\n",
680 buf, controller, channel, obytes, obps, ibytes, ibps);
683 display_acct(CHPOS(controller, channel), obytes, obps, ibytes, ibps);
688 print_initialization(void)
693 if(curses_ready == 0)
704 * Dispatch one message received from the daemon.
707 handle_event(u_int8_t *msg, int len)
709 u_int8_t cmd[I4B_MON_ICLIENT_SIZE];
714 static int first = 1;
718 case ST_INIT: /* initial data */
720 isdn_major = I4B_GET_2B(msg, I4B_MON_IDATA_VERSMAJOR);
721 isdn_minor = I4B_GET_2B(msg, I4B_MON_IDATA_VERSMINOR);
722 nctrl = I4B_GET_2B(msg, I4B_MON_IDATA_NUMCTRL);
723 nentries = I4B_GET_2B(msg, I4B_MON_IDATA_NUMENTR);
724 rights = I4B_GET_4B(msg, I4B_MON_IDATA_CLACCESS);
726 mprintf("remote protocol version is %02d.%02d\n", isdn_major, isdn_minor);
728 if(isdn_major != MPROT_VERSION || isdn_minor != MPROT_REL)
730 fprintf(stderr, "ERROR, remote protocol version mismatch:\n");
731 fprintf(stderr, "\tremote major version is %02d, local major version is %02d\n", isdn_major, MPROT_VERSION);
732 fprintf(stderr, "\tremote minor version is %02d, local minor version is %02d\n", isdn_minor, MPROT_REL);
736 mprintf("our rights = 0x%x\n", rights);
745 else if(nentries > 0)
753 print_initialization();
756 /* set maximum event mask */
757 I4B_PREP_CMD(cmd, I4B_MON_CCMD_SETMASK);
758 I4B_PUT_2B(cmd, I4B_MON_ICLIENT_VERMAJOR, MPROT_VERSION);
759 I4B_PUT_2B(cmd, I4B_MON_ICLIENT_VERMINOR, MPROT_REL);
760 I4B_PUT_4B(cmd, I4B_MON_ICLIENT_EVENTS, ~0U);
763 if(debug & DBG_DUMPALL)
764 dump_event(cmd, sizeof(cmd), 0);
767 if((sock_write(monsock, cmd, sizeof(cmd))) == -1)
769 fprintf(stderr, "sock_write failed: %s\n", strerror(errno));
774 case ST_ICTRL: /* initial controller list */
778 mprintf("%d controller(s) found:\n", nctrl);
780 mprintf("\tcontroller %d: %s\n", sub_state++, msg+I4B_MON_ICTRL_NAME);
782 if(sub_state >= nctrl)
788 state = ST_IDEV; /* end of list reached */
794 print_initialization();
799 case ST_IDEV: /* initial entry devicename list */
803 mprintf("%d entries found:\n", nentries);
806 mprintf("\tentry %d: device %s\n", sub_state++, msg+I4B_MON_IDEV_NAME);
808 strcat(devbuf, msg+I4B_MON_IDEV_NAME);
809 /* strcat(devbuf, " "); */
811 if(sub_state >= nentries)
814 state = ST_ANYEV; /* end of list reached */
817 print_initialization();
821 case ST_ANYEV: /* any event */
822 switch(I4B_GET_2B(msg, I4B_MON_EVNT))
824 case I4B_MON_DRINI_CODE:
825 state = ST_RIGHT; /* list of rights entries will follow */
827 sub_state_count = I4B_GET_2B(msg, I4B_MON_DRINI_COUNT);
828 mprintf("monitor rights:\n");
831 case I4B_MON_DCINI_CODE:
834 sub_state_count = I4B_GET_2B(msg, I4B_MON_DCINI_COUNT);
835 mprintf("monitor connections:\n");
838 case I4B_MON_LOGEVNT_CODE:
839 print_logevent(I4B_GET_4B(msg, I4B_MON_LOGEVNT_TSTAMP),
840 I4B_GET_4B(msg, I4B_MON_LOGEVNT_PRIO),
841 msg+I4B_MON_LOGEVNT_WHAT,
842 msg+I4B_MON_LOGEVNT_MSG);
845 case I4B_MON_CHRG_CODE:
846 print_charge(I4B_GET_4B(msg, I4B_MON_CHRG_TSTAMP),
847 I4B_GET_4B(msg, I4B_MON_CHRG_CTRL),
848 I4B_GET_4B(msg, I4B_MON_CHRG_CHANNEL),
849 I4B_GET_4B(msg, I4B_MON_CHRG_UNITS),
850 I4B_GET_4B(msg, I4B_MON_CHRG_ESTIMATED));
853 case I4B_MON_CONNECT_CODE:
855 I4B_GET_4B(msg, I4B_MON_CONNECT_TSTAMP),
856 I4B_GET_4B(msg, I4B_MON_CONNECT_DIR),
857 I4B_GET_4B(msg, I4B_MON_CONNECT_CTRL),
858 I4B_GET_4B(msg, I4B_MON_CONNECT_CHANNEL),
859 msg+I4B_MON_CONNECT_CFGNAME,
860 msg+I4B_MON_CONNECT_DEVNAME,
861 msg+I4B_MON_CONNECT_REMPHONE,
862 msg+I4B_MON_CONNECT_LOCPHONE);
865 case I4B_MON_DISCONNECT_CODE:
867 I4B_GET_4B(msg, I4B_MON_DISCONNECT_TSTAMP),
868 I4B_GET_4B(msg, I4B_MON_DISCONNECT_CTRL),
869 I4B_GET_4B(msg, I4B_MON_DISCONNECT_CHANNEL));
872 case I4B_MON_UPDOWN_CODE:
874 I4B_GET_4B(msg, I4B_MON_UPDOWN_TSTAMP),
875 I4B_GET_4B(msg, I4B_MON_UPDOWN_CTRL),
876 I4B_GET_4B(msg, I4B_MON_UPDOWN_CHANNEL),
877 I4B_GET_4B(msg, I4B_MON_UPDOWN_ISUP));
879 case I4B_MON_L12STAT_CODE:
881 I4B_GET_4B(msg, I4B_MON_L12STAT_TSTAMP),
882 I4B_GET_4B(msg, I4B_MON_L12STAT_CTRL),
883 I4B_GET_4B(msg, I4B_MON_L12STAT_LAYER),
884 I4B_GET_4B(msg, I4B_MON_L12STAT_STATE));
886 case I4B_MON_TEI_CODE:
888 I4B_GET_4B(msg, I4B_MON_TEI_TSTAMP),
889 I4B_GET_4B(msg, I4B_MON_TEI_CTRL),
890 I4B_GET_4B(msg, I4B_MON_TEI_TEI));
892 case I4B_MON_ACCT_CODE:
894 I4B_GET_4B(msg, I4B_MON_ACCT_TSTAMP),
895 I4B_GET_4B(msg, I4B_MON_ACCT_CTRL),
896 I4B_GET_4B(msg, I4B_MON_ACCT_CHAN),
897 I4B_GET_4B(msg, I4B_MON_ACCT_OBYTES),
898 I4B_GET_4B(msg, I4B_MON_ACCT_OBPS),
899 I4B_GET_4B(msg, I4B_MON_ACCT_IBYTES),
900 I4B_GET_4B(msg, I4B_MON_ACCT_IBPS));
903 mprintf("unknown event code: %d\n", I4B_GET_2B(msg, I4B_MON_EVNT));
907 case ST_RIGHT: /* one record in a list of monitor rights */
908 rights = I4B_GET_4B(msg, I4B_MON_DR_RIGHTS);
909 net = I4B_GET_4B(msg, I4B_MON_DR_NET);
910 mask = I4B_GET_4B(msg, I4B_MON_DR_MASK);
911 local = I4B_GET_1B(msg, I4B_MON_DR_LOCAL);
915 mprintf("\tlocal: rights = %x\n", rights);
919 mprintf("\tfrom: %d.%d.%d.%d, mask %d.%d.%d.%d, rights = %x\n",
920 (net >> 24) & 0x00ff, (net >> 16) & 0x00ff, (net >> 8) & 0x00ff, net & 0x00ff,
921 (mask >> 24) & 0x00ff, (mask >> 16) & 0x00ff, (mask >> 8) & 0x00ff, mask & 0x00ff,
927 if(sub_state >= sub_state_count)
930 print_initialization();
935 who = I4B_GET_4B(msg, I4B_MON_DC_WHO);
936 rights = I4B_GET_4B(msg, I4B_MON_DC_RIGHTS);
938 mprintf("\tfrom: %d.%d.%d.%d, rights = %x\n",
939 (who >> 24) & 0x00ff, (who >> 16) & 0x00ff, (who >> 8) & 0x00ff, who & 0x00ff,
944 if(sub_state >= sub_state_count)
947 print_initialization();
952 mprintf("unknown event from remote: local state = %d, evnt = %x, len = %d\n",
953 state, I4B_GET_2B(msg, I4B_MON_EVNT), len);
958 * Process input from user
964 int channel, controller;
966 fgets(buf, sizeof(buf), stdin);
972 u_int8_t cmd[I4B_MON_DUMPRIGHTS_SIZE];
973 I4B_PREP_CMD(cmd, I4B_MON_DUMPRIGHTS_CODE);
975 if(debug & DBG_DUMPALL)
976 dump_event(cmd, I4B_MON_DUMPRIGHTS_SIZE, 0);
979 if((sock_write(monsock, cmd, I4B_MON_DUMPRIGHTS_SIZE)) == -1)
981 fprintf(stderr, "sock_write failed: %s\n", strerror(errno));
989 u_int8_t cmd[I4B_MON_DUMPMCONS_SIZE];
990 I4B_PREP_CMD(cmd, I4B_MON_DUMPMCONS_CODE);
992 if(debug & DBG_DUMPALL)
993 dump_event(cmd, I4B_MON_DUMPMCONS_CODE, 0);
996 if((sock_write(monsock, cmd, I4B_MON_DUMPMCONS_SIZE)) == -1)
998 fprintf(stderr, "sock_write failed: %s\n", strerror(errno));
1006 u_int8_t cmd[I4B_MON_CFGREREAD_SIZE];
1007 I4B_PREP_CMD(cmd, I4B_MON_CFGREREAD_CODE);
1009 if(debug & DBG_DUMPALL)
1010 dump_event(cmd, I4B_MON_CFGREREAD_CODE, 0);
1013 if((sock_write(monsock, cmd, I4B_MON_CFGREREAD_SIZE)) == -1)
1015 fprintf(stderr, "sock_write failed: %s\n", strerror(errno));
1023 u_int8_t cmd[I4B_MON_HANGUP_SIZE];
1024 I4B_PREP_CMD(cmd, I4B_MON_HANGUP_CODE);
1026 printf("Which controller you wish to hangup? ");
1027 fgets(buf, sizeof(buf), stdin);
1028 controller = atoi(buf);
1029 I4B_PUT_4B(cmd, I4B_MON_HANGUP_CTRL, controller);
1031 printf("Which channel do you wish to hangup? ");
1032 fgets(buf, sizeof(buf), stdin);
1033 channel = atoi(buf);
1034 I4B_PUT_4B(cmd, I4B_MON_HANGUP_CHANNEL, channel);
1037 if(debug & DBG_DUMPALL)
1038 dump_event(cmd, I4B_MON_HANGUP_CHANNEL, 0);
1041 if((sock_write(monsock, cmd, I4B_MON_HANGUP_SIZE)) == -1)
1043 fprintf(stderr, "sock_write failed: %s\n", strerror(errno));
1063 u_int8_t cmd[I4B_MON_CFGREREAD_SIZE];
1064 I4B_PREP_CMD(cmd, I4B_MON_CFGREREAD_CODE);
1066 if(debug & DBG_DUMPALL)
1067 dump_event(cmd, I4B_MON_CFGREREAD_CODE, 0);
1069 if((sock_write(monsock, cmd, I4B_MON_CFGREREAD_SIZE)) == -1)
1071 fprintf(stderr, "sock_write failed: %s\n", strerror(errno));
1077 hangup(int ctrl, int chan)
1079 u_int8_t cmd[I4B_MON_HANGUP_SIZE];
1081 I4B_PREP_CMD(cmd, I4B_MON_HANGUP_CODE);
1082 I4B_PUT_4B(cmd, I4B_MON_HANGUP_CTRL, ctrl);
1083 I4B_PUT_4B(cmd, I4B_MON_HANGUP_CHANNEL, chan);
1086 if(debug & DBG_DUMPALL)
1087 dump_event(cmd, I4B_MON_HANGUP_CHANNEL, 0);
1090 if((sock_write(monsock, cmd, I4B_MON_HANGUP_SIZE)) == -1)
1092 fprintf(stderr, "sock_write failed: %s\n", strerror(errno));
1105 printf("Menu: <1> display rights, <2> display monitor connections,\n");
1106 printf(" <3> reread config file, <4> hangup \n");
1107 printf(" <9> quit isdnmonitor\n");
1113 sock_read(int fd, void *buf, size_t nbytes)
1124 if((nread = read(fd, ptr, nleft)) < 0)
1143 return(nbytes - nleft);
1147 sock_write(int fd, void *buf, size_t nbytes)
1158 if((nwritten = write(fd, ptr, nleft)) <= 0)
1177 mprintf(char *fmt, ...)
1179 #define PRBUFLEN 1024
1180 char buffer[PRBUFLEN];
1184 vsnprintf(buffer, PRBUFLEN-1, fmt, ap);
1187 if(!fullscreen || (fullscreen && (!curses_ready)))
1188 printf("%s", buffer);
1190 if(logfilename != NULL)
1192 fprintf(lfp, "%s", buffer);