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.5 2005/11/25 00:58:52 swildner 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 *---------------------------------------------------------------------------*/
163 main(int argc, char **argv)
169 WSAStartup(MAKEWORD(2, 0), &wsCaps);
172 portno = DEF_MONPORT;
176 while((i = getopt(argc, argv, "cd:f:h:p:l:")) != -1)
178 while((i = getopt(argc, argv, "cd:f:h:p:")) != -1)
193 if((sscanf(optarg, "%i", &debug)) != 1)
198 logfilename = optarg;
209 if((sscanf(optarg, "%i", &portno)) != 1)
219 if(hostname && sockpath)
221 fprintf(stderr, "Error: can not use local socket path on remote machine\n"
222 "conflicting options -h and -l!\n");
228 monsock = connect_local(sockpath);
236 monsock = connect_remote(hostname, portno);
245 fprintf(stderr, "Could not connect to i4b isdn daemon.\n");
249 if(logfilename != NULL)
251 if((lfp = fopen(logfilename, "w")) == NULL)
253 fprintf(stderr, "could not open logfile [%s], %s\n", logfilename, strerror(errno));
259 signal(SIGPIPE, SIG_IGN);
269 /*---------------------------------------------------------------------------
270 * Connect via tcp/ip.
271 * Return socket if successfull, -1 on error.
272 ---------------------------------------------------------------------------*/
274 connect_remote(char *host, int portno)
276 struct sockaddr_in sa;
280 h = gethostbyname(host);
284 fprintf(stderr, "could not resolve hostname '%s'\n", host);
288 remotesockfd = socket(AF_INET, SOCK_STREAM, 0);
290 if(remotesockfd == -1)
292 fprintf(stderr, "could not create remote monitor socket: %s\n", strerror(errno));
296 memset(&sa, 0, sizeof(sa));
299 sa.sin_len = sizeof(sa);
301 sa.sin_family = AF_INET;
302 sa.sin_port = htons(portno);
304 memcpy(&sa.sin_addr.s_addr, h->h_addr_list[0], sizeof(sa.sin_addr.s_addr));
306 if(connect(remotesockfd, (struct sockaddr *)&sa, sizeof(sa)) == -1)
308 fprintf(stderr, "could not connect remote monitor: %s\n", strerror(errno));
316 /*---------------------------------------------------------------------------
318 * Return socket on success, -1 on failure.
319 *---------------------------------------------------------------------------*/
321 connect_local(char *sockpath)
324 struct sockaddr_un sa;
326 /* check path length */
327 if(strlen(sockpath) >= sizeof(sa.sun_path))
329 fprintf(stderr, "pathname to long for local socket: %s\n",
334 /* create and setup socket */
335 s = socket(AF_LOCAL, SOCK_STREAM, 0);
339 fprintf(stderr, "could not create local monitor socket:%s\n", strerror(errno));
343 memset(&sa, 0, sizeof(sa));
345 sa.sun_len = sizeof(sa);
346 sa.sun_family = AF_LOCAL;
347 strcpy(sa.sun_path, sockpath);
349 if(connect(s, (struct sockaddr *)&sa, sizeof(sa)))
351 fprintf(stderr, "could not connect local monitor socket [%s]: %s\n", sockpath, strerror(errno));
358 /*---------------------------------------------------------------------------*
359 * data from keyboard available, read and process it
360 *---------------------------------------------------------------------------*/
369 case 0x0c: /* control L */
381 /*---------------------------------------------------------------------------
383 *---------------------------------------------------------------------------*/
394 FD_SET(fileno(stdin), &rd);
395 FD_SET(monsock, &rd);
397 select(monsock+1, &rd, &wr, &ex, NULL);
399 if(FD_ISSET(fileno(stdin), &rd))
402 if(fullscreen && curses_ready)
412 if(FD_ISSET(monsock, &rd))
417 /* Network transfer may deliver two or more packets concatenated.
418 * Peek at the header and read only one event at a time... */
420 bytes = recv(monsock, buf, I4B_MON_EVNT_HDR, MSG_PEEK);
434 mprintf("remote isdnd has closed our connection\n");
439 fprintf(stderr, "recv error: %s\n", strerror(errno));
444 if (bytes < I4B_MON_EVNT_HDR)
445 continue; /* errh? something must be wrong... */
447 bytes = I4B_GET_2B(buf, I4B_MON_EVNT_LEN);
449 if(bytes >= sizeof(buf))
451 fprintf(stderr, "mloop: socket recv buffer overflow %d!\n", bytes);
455 /* now we know the size, it fits, so lets read it! */
457 ret = sock_read(monsock, buf, bytes);
466 mprintf("remote isdnd has closed our connection\n");
471 mprintf("error reading from isdnd: %s", strerror(errno));
475 if(debug & DBG_DUMPALL)
476 dump_event(buf, ret, 1);
478 handle_event(buf, ret);
485 * Dump a complete event packet.
488 dump_event(u_int8_t *msg, int len, int read)
493 mprintf("read from socket:");
495 mprintf("write to socket:");
497 for(i = 0; i < len; i++)
500 mprintf("\n%02d: ", i);
501 mprintf("0x%02x %c ", msg[i], isprint(msg[i]) ? msg[i] : '.');
508 print_logevent(time_t tstamp, int prio, char * what, char * msg)
511 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
512 mprintf("log: %s prio %d what=%s msg=%s\n", buf, prio, what, msg);
517 if((!debug_noscreen) || (debug_noscreen && (((strcmp(what, "DBG"))) != 0)))
520 * FreeBSD-current integrated ncurses. Since then it is no longer possible
521 * to write to the last column in the logfilewindow without causing an
522 * automatic newline to occur resulting in a blank line in that window.
524 wprintw(lower_w, "%s %s %-.*s\n", buf, what,
525 COLS-((strlen(buf))+(strlen(what))+3), msg);
533 print_charge(time_t tstamp, int controller, int channel, int units, int estimated)
536 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
537 mprintf("%s: controller %d, channel %d, charge = %d%s\n",
538 buf, controller, channel, units, estimated ? " (estimated)" : "");
543 display_ccharge(CHPOS(controller, channel), units);
545 display_charge(CHPOS(controller, channel), units);
551 * Print a connect event.
552 * A real monitor would allocate state info for "channel" on this
556 * tstamp: server time of event
557 * outgoing: 0 = incoming, 1 = outgoing
558 * controller: controller number
559 * channel: channel no, used to identify this connection until disconnect
560 * cfgname: name of config entry/connection
561 * devname: device used (e.g. isp0)
562 * remphone: phone no of remote side
563 * locphone: local phone no
566 print_connect(time_t tstamp, int outgoing, int controller, int channel,
567 char *cfgname, char *devname, char *remphone, char *locphone)
572 remstate[controller].ch1state = 1;
574 remstate[controller].ch2state = 1;
576 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
579 mprintf("%s: calling out to '%s' [from msn: '%s']",
580 buf, remphone, locphone);
582 mprintf("%s: incoming call from '%s' [to msn: '%s']",
583 buf, remphone, locphone);
584 mprintf(", controller %d, channel %d, config '%s' on device '%s'\n",
585 controller, channel, cfgname, devname);
589 display_connect(CHPOS(controller, channel), outgoing, cfgname, remphone, devname);
594 * Print a disconnect event.
595 * A real monitor could free the "per connection" state
596 * for this channel now
599 print_disconnect(time_t tstamp, int controller, int channel)
604 remstate[controller].ch1state = 0;
606 remstate[controller].ch2state = 0;
608 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
610 mprintf("%s: controller %d, channel %d disconnected\n",
611 buf, controller, channel);
615 display_disconnect(CHPOS(controller, channel));
620 * Print an up- or down event
623 print_updown(time_t tstamp, int controller, int channel, int isup)
626 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
627 mprintf("%s: channel %d is %s\n",
628 buf, channel, isup ? "up" : "down");
632 * Print l1 / l2 status
635 print_l12stat(time_t tstamp, int controller, int layer, int state)
638 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
640 mprintf("%s: layer %d change on controller %d: %s\n",
641 buf, layer, controller, state ? "up" : "down");
644 display_l12stat(controller, layer, state);
652 print_tei(time_t tstamp, int controller, int tei)
655 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
657 mprintf("%s: controller %d, TEI is %d\n",
658 buf, controller, tei);
662 display_tei(controller, tei);
667 * Print accounting information
670 print_acct(time_t tstamp, int controller, int channel, int obytes, int obps,
671 int ibytes, int ibps)
674 strftime(buf, sizeof(buf), I4B_TIME_FORMAT, localtime(&tstamp));
676 mprintf("%s: controller %d, channel %d: %d obytes, %d obps, %d ibytes, %d ibps\n",
677 buf, controller, channel, obytes, obps, ibytes, ibps);
680 display_acct(CHPOS(controller, channel), obytes, obps, ibytes, ibps);
685 print_initialization(void)
690 if(curses_ready == 0)
701 * Dispatch one message received from the daemon.
704 handle_event(u_int8_t *msg, int len)
706 u_int8_t cmd[I4B_MON_ICLIENT_SIZE];
711 static int first = 1;
715 case ST_INIT: /* initial data */
717 isdn_major = I4B_GET_2B(msg, I4B_MON_IDATA_VERSMAJOR);
718 isdn_minor = I4B_GET_2B(msg, I4B_MON_IDATA_VERSMINOR);
719 nctrl = I4B_GET_2B(msg, I4B_MON_IDATA_NUMCTRL);
720 nentries = I4B_GET_2B(msg, I4B_MON_IDATA_NUMENTR);
721 rights = I4B_GET_4B(msg, I4B_MON_IDATA_CLACCESS);
723 mprintf("remote protocol version is %02d.%02d\n", isdn_major, isdn_minor);
725 if(isdn_major != MPROT_VERSION || isdn_minor != MPROT_REL)
727 fprintf(stderr, "ERROR, remote protocol version mismatch:\n");
728 fprintf(stderr, "\tremote major version is %02d, local major version is %02d\n", isdn_major, MPROT_VERSION);
729 fprintf(stderr, "\tremote minor version is %02d, local minor version is %02d\n", isdn_minor, MPROT_REL);
733 mprintf("our rights = 0x%x\n", rights);
742 else if(nentries > 0)
750 print_initialization();
753 /* set maximum event mask */
754 I4B_PREP_CMD(cmd, I4B_MON_CCMD_SETMASK);
755 I4B_PUT_2B(cmd, I4B_MON_ICLIENT_VERMAJOR, MPROT_VERSION);
756 I4B_PUT_2B(cmd, I4B_MON_ICLIENT_VERMINOR, MPROT_REL);
757 I4B_PUT_4B(cmd, I4B_MON_ICLIENT_EVENTS, ~0U);
760 if(debug & DBG_DUMPALL)
761 dump_event(cmd, sizeof(cmd), 0);
764 if((sock_write(monsock, cmd, sizeof(cmd))) == -1)
766 fprintf(stderr, "sock_write failed: %s\n", strerror(errno));
771 case ST_ICTRL: /* initial controller list */
775 mprintf("%d controller(s) found:\n", nctrl);
777 mprintf("\tcontroller %d: %s\n", sub_state++, msg+I4B_MON_ICTRL_NAME);
779 if(sub_state >= nctrl)
785 state = ST_IDEV; /* end of list reached */
791 print_initialization();
796 case ST_IDEV: /* initial entry devicename list */
800 mprintf("%d entries found:\n", nentries);
803 mprintf("\tentry %d: device %s\n", sub_state++, msg+I4B_MON_IDEV_NAME);
805 strcat(devbuf, msg+I4B_MON_IDEV_NAME);
806 /* strcat(devbuf, " "); */
808 if(sub_state >= nentries)
811 state = ST_ANYEV; /* end of list reached */
814 print_initialization();
818 case ST_ANYEV: /* any event */
819 switch(I4B_GET_2B(msg, I4B_MON_EVNT))
821 case I4B_MON_DRINI_CODE:
822 state = ST_RIGHT; /* list of rights entries will follow */
824 sub_state_count = I4B_GET_2B(msg, I4B_MON_DRINI_COUNT);
825 mprintf("monitor rights:\n");
828 case I4B_MON_DCINI_CODE:
831 sub_state_count = I4B_GET_2B(msg, I4B_MON_DCINI_COUNT);
832 mprintf("monitor connections:\n");
835 case I4B_MON_LOGEVNT_CODE:
836 print_logevent(I4B_GET_4B(msg, I4B_MON_LOGEVNT_TSTAMP),
837 I4B_GET_4B(msg, I4B_MON_LOGEVNT_PRIO),
838 msg+I4B_MON_LOGEVNT_WHAT,
839 msg+I4B_MON_LOGEVNT_MSG);
842 case I4B_MON_CHRG_CODE:
843 print_charge(I4B_GET_4B(msg, I4B_MON_CHRG_TSTAMP),
844 I4B_GET_4B(msg, I4B_MON_CHRG_CTRL),
845 I4B_GET_4B(msg, I4B_MON_CHRG_CHANNEL),
846 I4B_GET_4B(msg, I4B_MON_CHRG_UNITS),
847 I4B_GET_4B(msg, I4B_MON_CHRG_ESTIMATED));
850 case I4B_MON_CONNECT_CODE:
852 I4B_GET_4B(msg, I4B_MON_CONNECT_TSTAMP),
853 I4B_GET_4B(msg, I4B_MON_CONNECT_DIR),
854 I4B_GET_4B(msg, I4B_MON_CONNECT_CTRL),
855 I4B_GET_4B(msg, I4B_MON_CONNECT_CHANNEL),
856 msg+I4B_MON_CONNECT_CFGNAME,
857 msg+I4B_MON_CONNECT_DEVNAME,
858 msg+I4B_MON_CONNECT_REMPHONE,
859 msg+I4B_MON_CONNECT_LOCPHONE);
862 case I4B_MON_DISCONNECT_CODE:
864 I4B_GET_4B(msg, I4B_MON_DISCONNECT_TSTAMP),
865 I4B_GET_4B(msg, I4B_MON_DISCONNECT_CTRL),
866 I4B_GET_4B(msg, I4B_MON_DISCONNECT_CHANNEL));
869 case I4B_MON_UPDOWN_CODE:
871 I4B_GET_4B(msg, I4B_MON_UPDOWN_TSTAMP),
872 I4B_GET_4B(msg, I4B_MON_UPDOWN_CTRL),
873 I4B_GET_4B(msg, I4B_MON_UPDOWN_CHANNEL),
874 I4B_GET_4B(msg, I4B_MON_UPDOWN_ISUP));
876 case I4B_MON_L12STAT_CODE:
878 I4B_GET_4B(msg, I4B_MON_L12STAT_TSTAMP),
879 I4B_GET_4B(msg, I4B_MON_L12STAT_CTRL),
880 I4B_GET_4B(msg, I4B_MON_L12STAT_LAYER),
881 I4B_GET_4B(msg, I4B_MON_L12STAT_STATE));
883 case I4B_MON_TEI_CODE:
885 I4B_GET_4B(msg, I4B_MON_TEI_TSTAMP),
886 I4B_GET_4B(msg, I4B_MON_TEI_CTRL),
887 I4B_GET_4B(msg, I4B_MON_TEI_TEI));
889 case I4B_MON_ACCT_CODE:
891 I4B_GET_4B(msg, I4B_MON_ACCT_TSTAMP),
892 I4B_GET_4B(msg, I4B_MON_ACCT_CTRL),
893 I4B_GET_4B(msg, I4B_MON_ACCT_CHAN),
894 I4B_GET_4B(msg, I4B_MON_ACCT_OBYTES),
895 I4B_GET_4B(msg, I4B_MON_ACCT_OBPS),
896 I4B_GET_4B(msg, I4B_MON_ACCT_IBYTES),
897 I4B_GET_4B(msg, I4B_MON_ACCT_IBPS));
900 mprintf("unknown event code: %d\n", I4B_GET_2B(msg, I4B_MON_EVNT));
904 case ST_RIGHT: /* one record in a list of monitor rights */
905 rights = I4B_GET_4B(msg, I4B_MON_DR_RIGHTS);
906 net = I4B_GET_4B(msg, I4B_MON_DR_NET);
907 mask = I4B_GET_4B(msg, I4B_MON_DR_MASK);
908 local = I4B_GET_1B(msg, I4B_MON_DR_LOCAL);
912 mprintf("\tlocal: rights = %x\n", rights);
916 mprintf("\tfrom: %d.%d.%d.%d, mask %d.%d.%d.%d, rights = %x\n",
917 (net >> 24) & 0x00ff, (net >> 16) & 0x00ff, (net >> 8) & 0x00ff, net & 0x00ff,
918 (mask >> 24) & 0x00ff, (mask >> 16) & 0x00ff, (mask >> 8) & 0x00ff, mask & 0x00ff,
924 if(sub_state >= sub_state_count)
927 print_initialization();
932 who = I4B_GET_4B(msg, I4B_MON_DC_WHO);
933 rights = I4B_GET_4B(msg, I4B_MON_DC_RIGHTS);
935 mprintf("\tfrom: %d.%d.%d.%d, rights = %x\n",
936 (who >> 24) & 0x00ff, (who >> 16) & 0x00ff, (who >> 8) & 0x00ff, who & 0x00ff,
941 if(sub_state >= sub_state_count)
944 print_initialization();
949 mprintf("unknown event from remote: local state = %d, evnt = %x, len = %d\n",
950 state, I4B_GET_2B(msg, I4B_MON_EVNT), len);
955 * Process input from user
961 int channel, controller;
963 fgets(buf, sizeof(buf), stdin);
969 u_int8_t cmd[I4B_MON_DUMPRIGHTS_SIZE];
970 I4B_PREP_CMD(cmd, I4B_MON_DUMPRIGHTS_CODE);
972 if(debug & DBG_DUMPALL)
973 dump_event(cmd, I4B_MON_DUMPRIGHTS_SIZE, 0);
976 if((sock_write(monsock, cmd, I4B_MON_DUMPRIGHTS_SIZE)) == -1)
978 fprintf(stderr, "sock_write failed: %s\n", strerror(errno));
986 u_int8_t cmd[I4B_MON_DUMPMCONS_SIZE];
987 I4B_PREP_CMD(cmd, I4B_MON_DUMPMCONS_CODE);
989 if(debug & DBG_DUMPALL)
990 dump_event(cmd, I4B_MON_DUMPMCONS_CODE, 0);
993 if((sock_write(monsock, cmd, I4B_MON_DUMPMCONS_SIZE)) == -1)
995 fprintf(stderr, "sock_write failed: %s\n", strerror(errno));
1003 u_int8_t cmd[I4B_MON_CFGREREAD_SIZE];
1004 I4B_PREP_CMD(cmd, I4B_MON_CFGREREAD_CODE);
1006 if(debug & DBG_DUMPALL)
1007 dump_event(cmd, I4B_MON_CFGREREAD_CODE, 0);
1010 if((sock_write(monsock, cmd, I4B_MON_CFGREREAD_SIZE)) == -1)
1012 fprintf(stderr, "sock_write failed: %s\n", strerror(errno));
1020 u_int8_t cmd[I4B_MON_HANGUP_SIZE];
1021 I4B_PREP_CMD(cmd, I4B_MON_HANGUP_CODE);
1023 printf("Which controller you wish to hangup? ");
1024 fgets(buf, sizeof(buf), stdin);
1025 controller = atoi(buf);
1026 I4B_PUT_4B(cmd, I4B_MON_HANGUP_CTRL, controller);
1028 printf("Which channel do you wish to hangup? ");
1029 fgets(buf, sizeof(buf), stdin);
1030 channel = atoi(buf);
1031 I4B_PUT_4B(cmd, I4B_MON_HANGUP_CHANNEL, channel);
1034 if(debug & DBG_DUMPALL)
1035 dump_event(cmd, I4B_MON_HANGUP_CHANNEL, 0);
1038 if((sock_write(monsock, cmd, I4B_MON_HANGUP_SIZE)) == -1)
1040 fprintf(stderr, "sock_write failed: %s\n", strerror(errno));
1060 u_int8_t cmd[I4B_MON_CFGREREAD_SIZE];
1061 I4B_PREP_CMD(cmd, I4B_MON_CFGREREAD_CODE);
1063 if(debug & DBG_DUMPALL)
1064 dump_event(cmd, I4B_MON_CFGREREAD_CODE, 0);
1066 if((sock_write(monsock, cmd, I4B_MON_CFGREREAD_SIZE)) == -1)
1068 fprintf(stderr, "sock_write failed: %s\n", strerror(errno));
1074 hangup(int ctrl, int chan)
1076 u_int8_t cmd[I4B_MON_HANGUP_SIZE];
1078 I4B_PREP_CMD(cmd, I4B_MON_HANGUP_CODE);
1079 I4B_PUT_4B(cmd, I4B_MON_HANGUP_CTRL, ctrl);
1080 I4B_PUT_4B(cmd, I4B_MON_HANGUP_CHANNEL, chan);
1083 if(debug & DBG_DUMPALL)
1084 dump_event(cmd, I4B_MON_HANGUP_CHANNEL, 0);
1087 if((sock_write(monsock, cmd, I4B_MON_HANGUP_SIZE)) == -1)
1089 fprintf(stderr, "sock_write failed: %s\n", strerror(errno));
1102 printf("Menu: <1> display rights, <2> display monitor connections,\n");
1103 printf(" <3> reread config file, <4> hangup \n");
1104 printf(" <9> quit isdnmonitor\n");
1110 sock_read(int fd, void *buf, size_t nbytes)
1121 if((nread = read(fd, ptr, nleft)) < 0)
1140 return(nbytes - nleft);
1144 sock_write(int fd, void *buf, size_t nbytes)
1155 if((nwritten = write(fd, ptr, nleft)) <= 0)
1174 mprintf(char *fmt, ...)
1176 #define PRBUFLEN 1024
1177 char buffer[PRBUFLEN];
1181 vsnprintf(buffer, PRBUFLEN-1, fmt, ap);
1184 if(!fullscreen || (fullscreen && (!curses_ready)))
1185 printf("%s", buffer);
1187 if(logfilename != NULL)
1189 fprintf(lfp, "%s", buffer);