loop.c

   1 /*****************************************************************************\
   2 **                                                                           **
   3 ** LCR                                                                       **
   4 **                                                                           **
   5 **---------------------------------------------------------------------------**
   6 ** Copyright: Andreas Eversberg                                              **
   7 **                                                                           **
   8 ** loopback interface functions                                              **
   9 **                                                                           **
  10 \*****************************************************************************/
  11
  12 #include "main.h"
  13
  14 struct mISDNloop mISDNloop = { -1, 0 };
  15
  16 void mISDNloop_close(void)
  17 {
  18         if (mISDNloop.sock > -1)
  19                 close(mISDNloop.sock);
  20         mISDNloop.sock = -1;
  21 }
  22
  23 int mISDNloop_open()
  24 {
  25         int ret;
  26         int cnt;
  27         unsigned long on = 1;
  28         struct sockaddr_mISDN addr;
  29         struct mISDN_devinfo devinfo;
  30         int pri, bri;
  31
  32         /* already open */
  33         if (mISDNloop.sock > -1)
  34                 return 0;
  35
  36         PDEBUG(DEBUG_PORT, "Open external interface of loopback.\n");
  37
  38         /* check port counts */
  39         ret = ioctl(mISDNsocket, IMGETCOUNT, &cnt);
  40         if (ret < 0) {
  41                 fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret);
  42                 return(ret);
  43         }
  44
  45         if (cnt <= 0) {
  46                 PERROR_RUNTIME("Found no card. Please be sure to load card drivers.\n");
  47                 return -EIO;
  48         }
  49         mISDNloop.port = mISDN_getportbyname(mISDNsocket, cnt, options.loopback_ext);
  50         if (mISDNloop.port < 0) {
  51                 PERROR_RUNTIME("Port name '%s' not found, did you load loopback interface?.\n", options.loopback_ext);
  52                 return mISDNloop.port;
  53         }
  54         /* get protocol */
  55         bri = pri = 0;
  56         devinfo.id = mISDNloop.port;
  57         ret = ioctl(mISDNsocket, IMGETDEVINFO, &devinfo);
  58         if (ret < 0) {
  59                 PERROR_RUNTIME("Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", mISDNloop.port, ret);
  60                 return ret;
  61         }
  62         if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0)) {
  63                 bri = 1;
  64         }
  65         if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1)) {
  66                 pri = 1;
  67         }
  68         if (!bri && !pri) {
  69                 PERROR_RUNTIME("loop port %d does not support TE PRI or TE BRI.\n", mISDNloop.port);
  70         }
  71         /* open socket */
  72         if ((mISDNloop.sock = socket(PF_ISDN, SOCK_DGRAM, (pri)?ISDN_P_TE_E1:ISDN_P_TE_S0)) < 0) {
  73                 PERROR_RUNTIME("loop port %d failed to open socket.\n", mISDNloop.port);
  74                 mISDNloop_close();
  75                 return mISDNloop.sock;
  76         }
  77         /* set nonblocking io */
  78         if ((ret = ioctl(mISDNloop.sock, FIONBIO, &on)) < 0) {
  79                 PERROR_RUNTIME("loop port %d failed to set socket into nonblocking io.\n", mISDNloop.port);
  80                 mISDNloop_close();
  81                 return ret;
  82         }
  83         /* bind socket to dchannel */
  84         memset(&addr, 0, sizeof(addr));
  85         addr.family = AF_ISDN;
  86         addr.dev = mISDNloop.port;
  87         addr.channel = 0;
  88         if ((ret = bind(mISDNloop.sock, (struct sockaddr *)&addr, sizeof(addr))) < 0) {
  89                 PERROR_RUNTIME("loop port %d failed to bind socket. (name = %s errno=%d)\n", mISDNloop.port, options.loopback_ext, errno);
  90                 mISDNloop_close();
  91                 return (ret);
  92         }
  93
  94         return 0;
  95 }
  96
  97 int loop_hunt_bchannel(class PmISDN *port, struct mISDNport *mISDNport)
  98 {
  99         int channel;
 100         int i;
 101         char map[mISDNport->b_num];
 102         struct interface *interface;
 103         struct interface_port *ifport;
 104
 105         chan_trace_header(mISDNport, port, "CHANNEL SELECTION (setup)", DIRECTION_NONE);
 106         add_trace("channel", "reserved", "%d", mISDNport->b_reserved);
 107         if (mISDNport->b_reserved >= mISDNport->b_num) { // of out chan..
 108                 add_trace("conclusion", NULL, "all channels are reserved");
 109                 end_trace();
 110                 return(-34); // no channel
 111         }
 112
 113         /* map all used ports of shared loopback interface */
 114         memset(map, 0, sizeof(map));
 115         interface = interface_first;
 116         while(interface) {
 117                 ifport = interface->ifport;
 118                 while(ifport) {
 119                         if (!strcmp(ifport->portname, options.loopback_lcr)) {
 120                                 i = 0;
 121                                 while(i < mISDNport->b_num) {
 122                                         if (mISDNport->b_port[i])
 123                                                 map[i] = 1;
 124                                         i++;
 125                                 }
 126                         }
 127                         ifport = ifport->next;
 128                 }
 129                 interface = interface->next;
 130         }
 131
 132         /* find channel */
 133         i = 0;
 134         channel = 0;
 135         while(i < mISDNport->b_num) {
 136                 if (!map[i]) {
 137                         channel = i+1+(i>=15);
 138                         break;
 139                 }
 140                 i++;
 141         }
 142         if (!channel) {
 143                 add_trace("conclusion", NULL, "no channel available");
 144                 end_trace();
 145                 return(-6); // channel unacceptable
 146         }
 147         add_trace("conclusion", NULL, "channel available");
 148         add_trace("connect", "channel", "%d", channel);
 149         end_trace();
 150         return(channel);
 151 }
 152
 153