channels/chan_skinny.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Implementation of the Skinny protocol
   5  *
   6  * Asterisk is Copyright (C) 1999-2003 Mark Spencer
   7  *
   8  * chan_skinny was developed by Jeremy McNamara & Florian Overkamp
   9  *
  10  * This program is free software, distributed under the terms of
  11  * the GNU General Public License
  12  *
  13  */
  14
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <pthread.h>
  19 #include <string.h>
  20 #include <asterisk/lock.h>
  21 #include <asterisk/channel.h>
  22 #include <asterisk/channel_pvt.h>
  23 #include <asterisk/config.h>
  24 #include <asterisk/logger.h>
  25 #include <asterisk/module.h>
  26 #include <asterisk/pbx.h>
  27 #include <asterisk/options.h>
  28 #include <asterisk/lock.h>
  29 #include <asterisk/sched.h>
  30 #include <asterisk/io.h>
  31 #include <asterisk/rtp.h>
  32 #include <asterisk/acl.h>
  33 #include <asterisk/callerid.h>
  34 #include <asterisk/cli.h>
  35 #include <asterisk/say.h>
  36 #include <asterisk/cdr.h>
  37 #include <asterisk/astdb.h>
  38 #include <asterisk/parking.h>
  39 #include <asterisk/app.h>
  40 #include <asterisk/musiconhold.h>
  41 #include <asterisk/utils.h>
  42 #include <sys/socket.h>
  43 #include <netinet/in.h>
  44 #include <netinet/tcp.h>
  45 #include <sys/ioctl.h>
  46 #include <net/if.h>
  47 #include <errno.h>
  48 #include <unistd.h>
  49 #include <fcntl.h>
  50 #include <netdb.h>
  51 #include <arpa/inet.h>
  52 #include <sys/signal.h>
  53 #include <signal.h>
  54 #include <pthread.h>
  55 #include <asterisk/dsp.h>
  56 #include <ctype.h>
  57
  58 /************************************************************************************/
  59 /*                         Skinny/Asterisk Protocol Settings                        */
  60 /************************************************************************************/
  61 static char *desc = "Skinny Client Control Protocol (Skinny)";
  62 static char *tdesc = "Skinny Client Control Protocol (Skinny)";
  63 static char *type = "Skinny";
  64 static char *config = "skinny.conf";
  65
  66 /* Just about everybody seems to support ulaw, so make it a nice default */
  67 static int capability = AST_FORMAT_ULAW;
  68
  69 #define DEFAULT_SKINNY_PORT     2000
  70 #define DEFAULT_SKINNY_BACKLOG  2
  71 #define SKINNY_MAX_PACKET       1000
  72
  73 static int  keep_alive = 120;
  74 static char date_format[6] = "D-M-Y";
  75 static char version_id[16] = "P002F202";
  76
  77 // these should be in an include file, but dunno what to include
  78 typedef unsigned char  UINT8;
  79 typedef unsigned short UINT16;
  80 typedef unsigned int   UINT32;
  81
  82 /************************************************************************************/
  83 /*                                Protocol Messages                                 */
  84 /************************************************************************************/
  85 /* message types */
  86 #define KEEP_ALIVE_MESSAGE 0x0000
  87 /* no additional struct */
  88
  89 #define REGISTER_MESSAGE 0x0001
  90 typedef struct register_message {
  91         char name[16];
  92         int userId;
  93         int instance;
  94         char ip[4];
  95         int type;
  96         int maxStreams;
  97 } register_message;
  98
  99 #define IP_PORT_MESSAGE 0x0002
 100
 101 #define KEYPAD_BUTTON_MESSAGE 0x0003
 102 typedef struct keypad_button_message {
 103         int button;
 104 } keypad_button_message;
 105
 106 #define STIMULUS_MESSAGE 0x0005
 107 typedef struct stimulus_message {
 108         int stimulus;
 109         int stimulusInstance;
 110 } stimulus_message;
 111
 112 #define OFFHOOK_MESSAGE 0x0006
 113 #define ONHOOK_MESSAGE 0x0007
 114
 115 #define CAPABILITIES_RES_MESSAGE 0x0010
 116 typedef struct station_capabilities {
 117         int codec;
 118         int frames;
 119         union {
 120                 char res[8];
 121                 long rate;
 122         } payloads;
 123 } station_capabilities;
 124
 125 typedef struct capabilities_res_message {
 126         int count;
 127         struct station_capabilities caps[18];
 128 } capabilities_res_message;
 129
 130 #define SPEED_DIAL_STAT_REQ_MESSAGE 0x000A
 131 typedef struct speed_dial_stat_req_message {
 132         int speedDialNumber;
 133 } speed_dial_stat_req_message;
 134
 135 #define LINE_STATE_REQ_MESSAGE 0x000B
 136 typedef struct line_state_req_message {
 137         int lineNumber;
 138 } line_state_req_message;
 139
 140 #define TIME_DATE_REQ_MESSAGE 0x000D
 141 #define VERSION_REQ_MESSAGE 0x000F
 142 #define BUTTON_TEMPLATE_REQ_MESSAGE 0x000E
 143 #define SERVER_REQUEST_MESSAGE 0x0012
 144 #define ALARM_MESSAGE 0x0020
 145
 146 #define OPEN_RECIEVE_CHANNEL_ACK_MESSAGE 0x0022
 147 typedef struct open_recieve_channel_ack_message {
 148         int status;
 149         char ipAddr[4];
 150         int port;
 151         int passThruId;
 152 } open_recieve_channel_ack_message;
 153
 154 #define SOFT_KEY_SET_REQ_MESSAGE 0x0025
 155 #define UNREGISTER_MESSAGE 0x0027
 156 #define SOFT_KEY_TEMPLATE_REQ_MESSAGE 0x0028
 157
 158 #define REGISTER_ACK_MESSAGE 0x0081
 159 typedef struct register_ack_message {
 160         int keepAlive;
 161         char dateTemplate[6];
 162         char res[2];
 163         int secondaryKeepAlive;
 164         char res2[4];
 165 } register_ack_message;
 166
 167 #define START_TONE_MESSAGE 0x0082
 168 typedef struct start_tone_message {
 169         int tone;
 170 } start_tone_message;
 171
 172 #define STOP_TONE_MESSAGE 0x0083
 173
 174 #define SET_RINGER_MESSAGE 0x0085
 175 typedef struct set_ringer_message {
 176         int ringerMode;
 177 } set_ringer_message;
 178
 179 #define SET_LAMP_MESSAGE 0x0086
 180 typedef struct set_lamp_message {
 181         int stimulus;
 182         int stimulusInstance;
 183         int deviceStimulus;
 184 } set_lamp_message;
 185
 186 #define SET_SPEAKER_MESSAGE 0x0088
 187 typedef struct set_speaker_message {
 188         int mode;
 189 } set_speaker_message;
 190
 191 #define START_MEDIA_TRANSMISSION_MESSAGE 0x008A
 192 typedef struct media_qualifier {
 193         int precedence;
 194         int vad;
 195         int packets;
 196         int bitRate;
 197 } media_qualifier;
 198
 199 typedef struct start_media_transmission_message {
 200         int conferenceId;
 201         int passThruPartyId;
 202         char remoteIp[4];
 203         int remotePort;
 204         int packetSize;
 205         int payloadType;
 206         media_qualifier qualifier;
 207 } start_media_transmission_message;
 208
 209 #define STOP_MEDIA_TRANSMISSION_MESSAGE 0x008B
 210 typedef struct stop_media_transmission_message {
 211         int conferenceId;
 212         int passThruPartyId;
 213 } stop_media_transmission_message;
 214
 215 #define CALL_INFO_MESSAGE 0x008F
 216 typedef struct call_info_message {
 217         char callingPartyName[40];
 218         char callingParty[24];
 219         char calledPartyName[40];
 220         char calledParty[24];
 221         int  instance;
 222         int  reference;
 223         int  type;
 224         char originalCalledPartyName[40];
 225         char originalCalledParty[24];
 226 } call_info_message;
 227
 228 #define SPEED_DIAL_STAT_RES_MESSAGE 0x0091
 229 typedef struct speed_dial_stat_res_message {
 230         int speedDialNumber;
 231         char speedDialDirNumber[24];
 232         char speedDialDisplayName[40];
 233 } speed_dial_stat_res_message;
 234
 235 #define LINE_STAT_RES_MESSAGE 0x0092
 236 typedef struct line_stat_res_message {
 237         int  linenumber;
 238         char lineDirNumber[24];
 239         char lineDisplayName[42];
 240         int  space;
 241 } line_stat_res_message;
 242
 243 #define DEFINETIMEDATE_MESSAGE 0x0094
 244 typedef struct definetimedate_message {
 245         int year;       /* since 1900 */
 246         int month;
 247         int dayofweek;  /* monday = 1 */
 248         int day;
 249         int hour;
 250         int minute;
 251         int seconds;
 252         int milliseconds;
 253         int timestamp;
 254 } definetimedate_message;
 255
 256 #define DISPLAYTEXT_MESSAGE 0x0099
 257 typedef struct displaytext_message {
 258         char text[40];
 259 } displaytext_message;
 260
 261 #define REGISTER_REJ_MESSAGE 0x009D
 262 typedef struct register_rej_message {
 263         char errMsg[33];
 264 } register_rej_message;
 265
 266 #define CAPABILITIES_REQ_MESSAGE 0x009B
 267
 268 #define SERVER_RES_MESSAGE 0x009E
 269 typedef struct server_identifier {
 270         char serverName[48];
 271 } server_identifier;
 272
 273 typedef struct server_res_message {
 274         server_identifier server[5];
 275         int serverListenPort[5];
 276         int serverIpAddr[5];
 277 } server_res_message;
 278
 279 #define BUTTON_TEMPLATE_RES_MESSAGE 0x0097
 280 static const char *button_definition_hack = {
 281         "\x01\x09\x01\x02\x02\x02\x03\x02\x04\x02\x05\x02\x06\x02\x07\x02"
 282         "\x08\x02\x09\x02\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff"
 283         "\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff"
 284         "\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff"
 285         "\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff"
 286         "\x00\xff\x00\xff"
 287 };
 288
 289 typedef struct buttondefinition {
 290         UINT8 instanceNumber;
 291         UINT8 buttonDefinition;
 292 } button_definition;
 293
 294 typedef struct button_template_res_message {
 295         UINT32 buttonOffset;
 296         UINT32 buttonCount;
 297         UINT32 totalButtonCount;
 298         button_definition definition[42];
 299 } button_template_res_message;
 300
 301 #define VERSION_RES_MESSAGE 0x0098
 302 typedef struct version_res_message {
 303         char version[16];
 304 } version_res_message;
 305
 306 #define KEEP_ALIVE_ACK_MESSAGE 0x0100
 307
 308 #define OPEN_RECIEVE_CHANNEL_MESSAGE 0x0105
 309 typedef struct open_recieve_channel_message {
 310         int conferenceId;
 311         int partyId;
 312         int packets;
 313         int capability;
 314         int echo;
 315         int bitrate;
 316 } open_recieve_channel_message;
 317
 318 #define CLOSE_RECIEVE_CHANNEL_MESSAGE 0x0106
 319 typedef struct close_recieve_channel_message {
 320         int conferenceId;
 321         int partyId;
 322 } close_recieve_channel_message;
 323
 324 #define SOFT_KEY_TEMPLATE_RES_MESSAGE 0x0108
 325 static const char *soft_key_template_hack = {
 326         "\x52\x65\x64\x69\x61\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 327         "\x01\x00\x00\x00\x4e\x65\x77\x43\x61\x6c\6c\\x00\x00\x00\x00\x00"
 328         "\x00\x00\x00\x00\x02\x00\x00\x00\x48\x6f\x6c\x64\x00\x00\x00\x00"
 329         "\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x54\x72\x6e\x73"
 330         "\x66\x65\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00"
 331         "\x43\x46\x77\x64\x41\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05"
 332         "\x00\x00\x00\x43\x46\x77\x64\x20\x42\x75\x73\x79\x00\x00\x00\x00"
 333         "\x00\x00\x00\x06\x00\x00\x00\x43\x46\x77\x64\x4e\x6f\x41\x6e\x73"
 334         "\x77\x65\x72\x00\x00\x00\x00\x07\x00\x00\x00\x3c\x3c\x00\x00\x00"
 335         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x45"
 336         "\x6e\x64\x43\x61\x6c\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09"
 337         "\x00\x00\x00\x52\x65\x73\x75\x6d\x65\x00\x00\x00\x00\x00\x00\x00"
 338         "\x00\x00\x0a\x00\x00\x00\x41\x6e\x73\x77\x65\x72\x00\x00\x00\x00"
 339         "\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x49\x6e\x66\x6f\x00\x00"
 340         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x43\x6f"
 341         "\x6e\x66\x72\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00"
 342         "\x00\x50\x61\x72\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 343         "\x00\x0e\x00\x00\x00\x4a\x6f\x69\x6e\x00\x00\x00\x00\x00\x00\x00"
 344         "\x00\x00\x00\x00\x0f\x00\x00\x00\x4d\x65\x65\x74\x4d\x65\x00\x00"
 345         "\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x50\x69\x63\x6b"
 346         "\x55\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00"
 347         "\x47\x50\x69\x63\x6b\x55\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 348         "\x12\x00\x00\x00\x52\x6d\x4c\x73\x43\x00\x00\x00\x00\x00\x00\x00"
 349         "\x00\x00\x00\x13\x00\x00\x00\x42\x61\x72\x67\x65\x00\x00\x00\x00"
 350         "\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x42\x61\x72\x67\x65"
 351         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00"
 352 };
 353
 354 typedef struct soft_key_template_definition {
 355         char softKeyLabel[16];
 356         int softKeyEvent;
 357 } soft_key_template_definition;
 358
 359 typedef struct soft_key_template {
 360         int softKeyOffset;
 361         int softKeyCount;
 362         int totalSoftKeyCount;
 363     soft_key_template_definition softKeyTemplateDefinition[32];
 364 } soft_key_template;
 365
 366 #define SOFT_KEY_SET_RES_MESSAGE 0x0109
 367 static const char *soft_key_set_hack = {
 368         "\x01\x02\x05\x03\x09\x0a\x0b\x10\x11\x12\x04\x0e\x0d\x00\x00\x00"
 369         "\x2d\x01\x2e\x01\x31\x01\x2f\x01\x35\x01\x36\x01\x37\x01\x3c\x01"
 370         "\x3d\x01\x3e\x01\x30\x01\x3a\x01\x39\x01\x00\x00\x00\x00\x00\x00"
 371         "\x03\x09\x04\x0e\x0d\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 372         "\x2f\x01\x35\x01\x30\x01\x3a\x01\x39\x01\x3f\x01\x00\x00\x00\x00"
 373         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 374         "\x0a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 375         "\x36\x01\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 376         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 377         "\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 378         "\x37\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 379         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 380         "\x01\x09\x05\x10\x11\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 381         "\x2d\x01\x35\x01\x31\x01\x3c\x01\x3d\x01\x3e\x01\x00\x00\x00\x00"
 382         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 383         "\x00\x09\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 384         "\x00\x00\x35\x01\x30\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 385         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 386         "\x08\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 387         "\x34\x01\x35\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 388         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 389         "\x00\x09\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 390         "\x00\x00\x35\x01\x39\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 391         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 392         "\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 393         "\x00\x00\x35\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 394         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 395         "\x01\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 396         "\x2d\x01\x35\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 397         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 398         "\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 399         "\x41\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 400         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 401 };
 402
 403 typedef struct soft_key_set_definition {
 404         UINT8  softKeyTemplateIndex[16];
 405         UINT16 softKeyInfoIndex[16];
 406 } soft_key_set_definition;
 407
 408 typedef struct soft_key_sets {
 409         UINT32 softKeySetOffset;
 410         UINT32 softKeySetCount;
 411         UINT32 totalSoftKeySetCount;
 412         soft_key_set_definition softKeySetDefinition[16];
 413         UINT32 res;
 414 } soft_key_sets;
 415
 416 #define SELECT_SOFT_KEYS_MESSAGE 0x0110
 417 typedef struct select_soft_keys_message {
 418         int instance;
 419         int reference;
 420         int softKeySetIndex;
 421         int validKeyMask;
 422 } select_soft_keys_message;
 423
 424 #define CALL_STATE_MESSAGE 0x0111
 425 typedef struct call_state_message {
 426         int callState;
 427         int lineInstance;
 428         int callReference;
 429 } call_state_message;
 430
 431 #define ACTIVATE_CALL_PLANE_MESSAGE 0x0116
 432 typedef struct activate_call_plane_message {
 433         int lineInstance;
 434 } activate_call_plane_message;
 435
 436 /* packet composition */
 437 typedef struct {
 438         int len;
 439         int res;
 440         int e;
 441         union {
 442                 speed_dial_stat_req_message speeddialreq;
 443                 register_message reg;
 444                 register_ack_message regack;
 445                 register_rej_message regrej;
 446                 capabilities_res_message caps;
 447                 version_res_message version;
 448                 button_template_res_message buttontemplate;
 449                 displaytext_message displaytext;
 450                 definetimedate_message definetimedate;
 451                 start_tone_message starttone;
 452                 speed_dial_stat_res_message speeddial;
 453                 line_state_req_message line;
 454                 line_stat_res_message linestat;
 455                 soft_key_sets softkeysets;
 456                 soft_key_template softkeytemplate;
 457                 server_res_message serverres;
 458                 set_lamp_message setlamp;
 459                 set_ringer_message setringer;
 460                 call_state_message callstate;
 461                 keypad_button_message keypad;
 462                 select_soft_keys_message selectsoftkey;
 463                 activate_call_plane_message activatecallplane;
 464                 stimulus_message stimulus;
 465                 set_speaker_message setspeaker;
 466                 call_info_message callinfo;
 467                 start_media_transmission_message startmedia;
 468                 stop_media_transmission_message stopmedia;
 469                 open_recieve_channel_message openrecievechannel;
 470                 open_recieve_channel_ack_message openrecievechannelack;
 471                 close_recieve_channel_message closerecievechannel;
 472         } data;
 473 } skinny_req;
 474
 475 /************************************************************************************/
 476 /*                            Asterisk specific globals                             */
 477 /************************************************************************************/
 478
 479 static int skinnydebug = 1;     /* XXX for now, enable debugging default */
 480
 481 /* a hostname, portnumber, socket and such is usefull for VoIP protocols */
 482 static struct sockaddr_in bindaddr;
 483 static char ourhost[256];
 484 static int ourport;
 485 static struct in_addr __ourip;
 486 struct ast_hostent ahp; struct hostent *hp;
 487 static int skinnysock  = -1;
 488 static pthread_t tcp_thread;
 489 static pthread_t accept_t;
 490 static char context[AST_MAX_EXTENSION] = "default";
 491 static char language[MAX_LANGUAGE] = "";
 492 static char musicclass[MAX_LANGUAGE] = "";
 493 static char callerid[AST_MAX_EXTENSION] = "";
 494 static char linelabel[AST_MAX_EXTENSION] ="";
 495 static int nat = 0;
 496 static unsigned int cur_callergroup = 0;
 497 static unsigned int cur_pickupgroup = 0;
 498 static int immediate = 0;
 499 static int callwaiting = 0;
 500 static int callreturn = 0;
 501 static int threewaycalling = 0;
 502 /* This is for flashhook transfers */
 503 static int transfer = 0;
 504 static int cancallforward = 0;
 505 /*static int busycount = 3;*/
 506 static char accountcode[20] = "";
 507 static char mailbox[AST_MAX_EXTENSION];
 508 static int amaflags = 0;
 509 static int callnums = 1;
 510
 511
 512 #define SUB_REAL 0
 513 #define SUB_ALT  1
 514 #define MAX_SUBS 2
 515
 516 #define SKINNY_SPEAKERON 1
 517 #define SKINNY_SPEAKEROFF 2
 518
 519 #define SKINNY_OFFHOOK 1
 520 #define SKINNY_ONHOOK 2
 521 #define SKINNY_RINGOUT 3
 522 #define SKINNY_RINGIN 4
 523 #define SKINNY_CONNECTED 5
 524 #define SKINNY_BUSY 6
 525 #define SKINNY_CONGESTION 7
 526 #define SKINNY_HOLD 8
 527 #define SKINNY_CALLWAIT 9
 528 #define SKINNY_TRANSFER 10
 529 #define SKINNY_PARK 11
 530 #define SKINNY_PROGRESS 12
 531 #define SKINNY_INVALID 14
 532
 533 #define SKINNY_SILENCE 0
 534 #define SKINNY_DIALTONE 33
 535 #define SKINNY_BUSYTONE 35
 536 #define SKINNY_ALERT 36
 537 #define SKINNY_REORDER 37
 538 #define SKINNY_CALLWAITTONE 45
 539
 540 #define SKINNY_LAMP_OFF 1
 541 #define SKINNY_LAMP_ON  2
 542 #define SKINNY_LAMP_WINK 3
 543 #define SKINNY_LAMP_FLASH 4
 544 #define SKINNY_LAMP_BLINK 5
 545
 546 #define SKINNY_RING_OFF 1
 547 #define SKINNY_RING_INSIDE 2
 548 #define SKINNY_RING_OUTSIDE 3
 549 #define SKINNY_RING_FEATURE 4
 550
 551 #define TYPE_TRUNK              1
 552 #define TYPE_LINE               2
 553
 554 #define STIMULUS_REDIAL 1
 555 #define STIMULUS_SPEEDDIAL 2
 556 #define STIMULUS_HOLD 3
 557 #define STIMULUS_TRANSFER 4
 558 #define STIMULUS_FORWARDALL 5
 559 #define STIMULUS_FORWARDBUSY 6
 560 #define STIMULUS_FORWARDNOANSWER 7
 561 #define STIMULUS_DISPLAY 8
 562 #define STIMULUS_LINE 9
 563
 564 /* Skinny rtp stream modes */
 565 #define SKINNY_CX_SENDONLY 0
 566 #define SKINNY_CX_RECVONLY 1
 567 #define SKINNY_CX_SENDRECV 2
 568 #define SKINNY_CX_CONF     3
 569 #define SKINNY_CX_CONFERENCE 3
 570 #define SKINNY_CX_MUTE     4
 571 #define SKINNY_CX_INACTIVE 4
 572
 573 #if 0
 574 static char *skinny_cxmodes[] = {
 575     "sendonly",
 576     "recvonly",
 577     "sendrecv",
 578     "confrnce",
 579     "inactive"
 580 };
 581 #endif
 582
 583 /* driver scheduler */
 584 static struct sched_context *sched;
 585 static struct io_context *io;
 586
 587 /* usage count and locking */
 588 static int usecnt = 0;
 589 static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER;
 590
 591 /* Protect the monitoring thread, so only one process can kill or start it, and not
 592    when it's doing something critical. */
 593 static ast_mutex_t monlock         = AST_MUTEX_INITIALIZER;
 594 /* Protect the network socket */
 595 static ast_mutex_t netlock         = AST_MUTEX_INITIALIZER;
 596 /* Protect the session list */
 597 static ast_mutex_t sessionlock = AST_MUTEX_INITIALIZER;
 598 /* Protect the device list */
 599 static ast_mutex_t devicelock = AST_MUTEX_INITIALIZER;
 600
 601 /* This is the thread for the monitor which checks for input on the channels
 602    which are not currently in use.  */
 603 static pthread_t monitor_thread = AST_PTHREADT_NULL;
 604
 605 /* Wait up to 16 seconds for first digit */
 606 static int firstdigittimeout = 16000;
 607
 608 /* How long to wait for following digits */
 609 static int gendigittimeout = 8000;
 610
 611 /* How long to wait for an extra digit, if there is an ambiguous match */
 612 static int matchdigittimeout = 3000;
 613
 614 struct skinny_subchannel {
 615         ast_mutex_t lock;
 616         unsigned int callid;
 617         struct ast_channel *owner;
 618         struct skinny_line *parent;
 619         struct ast_rtp *rtp;
 620         time_t lastouttime;
 621         int lastout;
 622         int cxmode;
 623         int nat;
 624         int outgoing;
 625         int alreadygone;
 626         struct skinny_subchannel *next; /* for our circular linked list */
 627 };
 628
 629 struct skinny_line {
 630         ast_mutex_t lock;
 631         char name[80];
 632         char label[42];                                 /* Label that shows next to the line buttons */
 633         struct skinny_subchannel *sub;                  /* pointer to our current connection, channel and stuff */
 634         char accountcode[80];
 635         char exten[AST_MAX_EXTENSION];                  /* Extention where to start */
 636         char context[AST_MAX_EXTENSION];
 637         char language[MAX_LANGUAGE];
 638         char callerid[AST_MAX_EXTENSION];               /* Caller*ID */
 639         char lastcallerid[AST_MAX_EXTENSION];           /* Last Caller*ID */
 640         char call_forward[AST_MAX_EXTENSION];
 641         char mailbox[AST_MAX_EXTENSION];
 642         char musicclass[MAX_LANGUAGE];
 643         int curtone;                                    /* Current tone */
 644         unsigned int callgroup;
 645         unsigned int pickupgroup;
 646         int callwaiting;
 647         int transfer;
 648         int threewaycalling;
 649         int cancallforward;
 650         int callreturn;
 651         int dnd; /* How does this affect callwait?  Do we just deny a skinny_request if we're dnd? */
 652         int hascallerid;
 653         int hidecallerid;
 654         int amaflags;
 655         int type;
 656         int instance;
 657         int group;
 658         int needdestroy;
 659         int capability;
 660         int nonCodecCapability;
 661         int onhooktime;
 662         int msgstate;           /* voicemail message state */
 663         int immediate;
 664         int hookstate;
 665         int progress;
 666         struct skinny_line *next;
 667         struct skinny_device *parent;
 668 };
 669
 670 static struct skinny_device {
 671         /* A device containing one or more lines */
 672         char name[80];
 673         char id[16];
 674         char version_id[16];
 675         int type;
 676         int registered;
 677         struct sockaddr_in addr;
 678         struct in_addr ourip;
 679         struct skinny_line *lines;
 680         struct ast_ha *ha;
 681         struct skinnysession *session;
 682         struct skinny_device *next;
 683 } *devices = NULL;
 684
 685 static struct skinnysession {
 686         pthread_t t;
 687         ast_mutex_t lock;
 688         struct sockaddr_in sin;
 689         int fd;
 690         char inbuf[SKINNY_MAX_PACKET];
 691         struct skinny_device *device;
 692         struct skinnysession *next;
 693 } *sessions = NULL;
 694
 695 static skinny_req *req_alloc(size_t size)
 696 {
 697         skinny_req *req;
 698         req = malloc(size+12);
 699         if (!req) {
 700                 return NULL;
 701         }
 702         memset(req, 0, size+12);
 703         return req;
 704 }
 705
 706 static struct skinny_subchannel *find_subchannel_by_line(struct skinny_line *l)
 707 {
 708         /* XXX Need to figure out how to determine which sub we want */
 709         struct skinny_subchannel *sub = l->sub;
 710         return sub;
 711 }
 712
 713 static struct skinny_subchannel *find_subchannel_by_name(char *dest)
 714 {
 715         struct skinny_line *l;
 716         struct skinny_device *d;
 717         char line[256];
 718         char *at;
 719         char *device;
 720
 721         strncpy(line, dest, sizeof(line) - 1);
 722         at = strchr(line, '@');
 723         if (!at) {
 724                 ast_log(LOG_NOTICE, "Device '%s' has no @ (at) sign!\n", dest);
 725                 return NULL;
 726         }
 727         *at = '\0';
 728         at++;
 729         device = at;
 730         ast_mutex_lock(&devicelock);
 731         d = devices;
 732         while(d) {
 733                 if (!strcasecmp(d->name, device)) {
 734                         if (skinnydebug) {
 735                                 ast_verbose("Found device: %s\n", d->name);
 736                         }
 737                         /* Found the device */
 738                         l = d->lines;
 739                         while (l) {
 740                                 /* Search for the right line */
 741                                 if (!strcasecmp(l->name, line)) {
 742                                         ast_mutex_unlock(&devicelock);
 743                                         return l->sub;
 744                                 }
 745                                 l = l->next;
 746                         }
 747                 }
 748                 d = d->next;
 749         }
 750         /* Device not found*/
 751         ast_mutex_unlock(&devicelock);
 752         return NULL;
 753 }
 754
 755 static int transmit_response(struct skinnysession *s, skinny_req *req)
 756 {
 757         int res = 0;
 758         ast_mutex_lock(&s->lock);
 759 #if 0
 760         ast_verbose("writing packet type %d (%d bytes) to socket %d\n", req->e, req->len+8, s->fd);
 761 #endif
 762         res = write(s->fd, req, req->len+8);
 763         if (res != req->len+8) {
 764                 ast_log(LOG_WARNING, "Transmit: write only sent %d out of %d bytes: %s\n", res, req->len+8, strerror(errno));
 765         }
 766         ast_mutex_unlock(&s->lock);
 767         return 1;
 768 }
 769
 770 /* XXX Do this right*/
 771 static int convert_cap(int capability)
 772 {
 773         return 4; // ulaw (this is not the same as asterisk's '4'  :)
 774
 775 }
 776
 777 static void transmit_speaker_mode(struct skinnysession *s, int mode)
 778 {
 779         skinny_req *req;
 780
 781         req = req_alloc(sizeof(struct set_speaker_message));
 782         if (!req) {
 783                 ast_log(LOG_ERROR, "Unable to allocate skinny_request, this is bad\n");
 784                 return;
 785         }
 786         req->len = sizeof(set_speaker_message)+4;
 787         req->e = SET_SPEAKER_MESSAGE;
 788         req->data.setspeaker.mode = mode;
 789         transmit_response(s, req);
 790 }
 791
 792 static void transmit_callstate(struct skinnysession *s, int instance, int state, unsigned callid)
 793 {
 794         skinny_req *req;
 795         int memsize = sizeof(struct call_state_message);
 796
 797         req = req_alloc(memsize);
 798         if (!req) {
 799                 ast_log(LOG_ERROR, "Unable to allocate skinny_request, this is bad\n");
 800                 return;
 801         }
 802         if (state == SKINNY_ONHOOK) {
 803                 transmit_speaker_mode(s, SKINNY_SPEAKEROFF);
 804         }
 805         req->len = sizeof(call_state_message)+4;
 806         req->e = CALL_STATE_MESSAGE;
 807         req->data.callstate.callState = state;
 808         req->data.callstate.lineInstance = instance;
 809         req->data.callstate.callReference = callid;
 810         transmit_response(s, req);
 811         if (state == SKINNY_OFFHOOK) {
 812                 memset(req, 0, memsize);
 813                 req->len = sizeof(activate_call_plane_message)+4;
 814                 req->e = ACTIVATE_CALL_PLANE_MESSAGE;
 815                 req->data.activatecallplane.lineInstance = instance;
 816                 transmit_response(s, req);
 817         } else if (state == SKINNY_ONHOOK) {
 818                 memset(req, 0, memsize);
 819                 req->len = sizeof(activate_call_plane_message)+4;
 820                 req->e = ACTIVATE_CALL_PLANE_MESSAGE;
 821                 req->data.activatecallplane.lineInstance = 0;
 822                 transmit_response(s, req);
 823                 memset(req, 0, memsize);
 824                 req->len = sizeof(close_recieve_channel_message)+4;
 825                 req->e = CLOSE_RECIEVE_CHANNEL_MESSAGE;
 826                 req->data.closerecievechannel.conferenceId = 0;
 827                 req->data.closerecievechannel.partyId = 0;
 828                 transmit_response(s, req);
 829                 memset(req, 0, memsize);
 830                 req->len = sizeof(stop_media_transmission_message)+4;
 831                 req->e = STOP_MEDIA_TRANSMISSION_MESSAGE;
 832                 req->data.stopmedia.conferenceId = 0;
 833                 req->data.stopmedia.passThruPartyId = 0;
 834                 transmit_response(s, req);
 835         }
 836 }
 837
 838 static void transmit_connect(struct skinnysession *s)
 839 {
 840         skinny_req *req;
 841         struct skinny_line *l = s->device->lines;
 842
 843         req = req_alloc(sizeof(struct open_recieve_channel_message));
 844         if (!req) {
 845                 ast_log(LOG_ERROR, "Unable to allocate skinny_request, this is bad\n");
 846                 return;
 847         }
 848         req->len = sizeof(struct call_info_message);
 849         req->e = OPEN_RECIEVE_CHANNEL_MESSAGE;
 850         req->data.openrecievechannel.conferenceId = 0;
 851         req->data.openrecievechannel.partyId = 0;
 852         req->data.openrecievechannel.packets = 20;
 853         req->data.openrecievechannel.capability = convert_cap(l->capability);
 854         req->data.openrecievechannel.echo = 0;
 855         req->data.openrecievechannel.bitrate = 0;
 856         transmit_response(s, req);
 857 }
 858
 859 static void transmit_tone(struct skinnysession *s, int tone)
 860 {
 861         skinny_req *req;
 862
 863         if (tone > 0)
 864                 req = req_alloc(sizeof(struct start_tone_message));
 865         else
 866                 req = req_alloc(4);
 867         if (!req) {
 868                 ast_log(LOG_ERROR, "Unable to allocate skinny_request, this is bad\n");
 869                 return;
 870         }
 871         if (tone > 0) {
 872                 req->len = sizeof(start_tone_message)+4;
 873                 req->e = START_TONE_MESSAGE;
 874                 req->data.starttone.tone = tone; // da tone
 875         } else {
 876                 req->len = 4;
 877                 req->e = STOP_TONE_MESSAGE;
 878         }
 879         transmit_response(s, req);
 880 }
 881
 882 #if 0
 883 static void transmit_selectsoftkeys(struct skinnysession *s, int instance, int callid, int softkey)
 884 {
 885         skinny_req *req;
 886         int memsize = sizeof(struct select_soft_keys_message);
 887
 888         req = req_alloc(memsize);
 889         if (!req) {
 890                 ast_log(LOG_ERROR, "Unable to allocate skinny_request, this is bad\n");
 891                 return;
 892         }
 893         memset(req, 0, memsize);
 894         req->len = sizeof(select_soft_keys_message)+4;
 895         req->e = SELECT_SOFT_KEYS_MESSAGE;
 896         req->data.selectsoftkey.instance = instance;
 897         req->data.selectsoftkey.reference = callid;
 898         req->data.selectsoftkey.softKeySetIndex = softkey;
 899         transmit_response(s, req);
 900 }
 901 #endif
 902
 903 static void transmit_lamp_indication(struct skinnysession *s, int instance, int indication)
 904 {
 905         skinny_req *req;
 906
 907         req = req_alloc(sizeof(struct set_lamp_message));
 908         if (!req) {
 909                 ast_log(LOG_ERROR, "Unable to allocate skinny_request, this is bad\n");
 910                 return;
 911         }
 912         req->len = sizeof(set_lamp_message)+4;
 913         req->e = SET_LAMP_MESSAGE;
 914         req->data.setlamp.stimulus = 0x9;  // magic number
 915         req->data.setlamp.stimulusInstance = instance;
 916         req->data.setlamp.deviceStimulus = indication;
 917         transmit_response(s, req);
 918 }
 919
 920 static void transmit_ringer_mode(struct skinnysession *s, int mode)
 921 {
 922         skinny_req *req;
 923
 924         req = req_alloc(sizeof(struct set_ringer_message));
 925         if (!req) {
 926                 ast_log(LOG_ERROR, "Unable to allocate skinny_request, this is bad\n");
 927                 return;
 928         }
 929         req->len = sizeof(set_ringer_message)+4;
 930         req->e = SET_RINGER_MESSAGE;
 931         req->data.setringer.ringerMode = mode;
 932         transmit_response(s, req);
 933 }
 934
 935 /* I do not believe skinny can deal with video.
 936    Anyone know differently? */
 937 static struct ast_rtp *skinny_get_vrtp_peer(struct ast_channel *chan)
 938 {
 939         return NULL;
 940 }
 941
 942 static struct ast_rtp *skinny_get_rtp_peer(struct ast_channel *chan)
 943 {
 944         struct skinny_subchannel *sub;
 945         sub = chan->pvt->pvt;
 946         if (sub && sub->rtp)
 947                 return sub->rtp;
 948         return NULL;
 949 }
 950
 951 static int skinny_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp)
 952 {
 953         struct skinny_subchannel *sub;
 954         sub = chan->pvt->pvt;
 955         if (sub) {
 956                 /* transmit_modify_with_sdp(sub, rtp); @@FIXME@@ if needed */
 957                 return 0;
 958         }
 959         return -1;
 960 }
 961
 962 static struct ast_rtp_protocol skinny_rtp = {
 963         get_rtp_info: skinny_get_rtp_peer,
 964         get_vrtp_info: skinny_get_vrtp_peer,
 965         set_rtp_peer: skinny_set_rtp_peer,
 966 };
 967
 968 static int skinny_do_debug(int fd, int argc, char *argv[])
 969 {
 970         if (argc != 2)
 971                 return RESULT_SHOWUSAGE;
 972         skinnydebug = 1;
 973         ast_cli(fd, "Skinny Debugging Enabled\n");
 974         return RESULT_SUCCESS;
 975 }
 976
 977 static int skinny_no_debug(int fd, int argc, char *argv[])
 978 {
 979         if (argc != 3)
 980                 return RESULT_SHOWUSAGE;
 981         skinnydebug = 0;
 982         ast_cli(fd, "Skinny Debugging Disabled\n");
 983         return RESULT_SUCCESS;
 984 }
 985
 986 static int skinny_show_lines(int fd, int argc, char *argv[])
 987 {
 988         struct skinny_device  *d;
 989         struct skinny_line *l;
 990         int haslines = 0;
 991         if (argc != 3)
 992                 return RESULT_SHOWUSAGE;
 993         ast_mutex_lock(&devicelock);
 994         d = devices;
 995         while(d) {
 996                 l = d->lines;
 997                 ast_cli(fd, "Device '%s' at %s\n", d->name, inet_ntoa(d->addr.sin_addr));
 998                 while(l) {
 999                         ast_cli(fd, "   -- '%s@%s in '%s' is %s\n", l->name, d->name, l->context, l->sub->owner ? "active" : "idle");
1000                         haslines = 1;
1001                         l = l->next;
1002                 }
1003                 if (!haslines) {
1004                         ast_cli(fd, "   << No Lines Defined >>     ");
1005                 }
1006                 d = d->next;
1007         }
1008         ast_mutex_unlock(&devicelock);
1009         return RESULT_SUCCESS;
1010 }
1011
1012 static char show_lines_usage[] =
1013 "Usage: skinny show lines\n"
1014 "       Lists all lines known to the Skinny subsystem.\n";
1015
1016 static char debug_usage[] =
1017 "Usage: skinny debug\n"
1018 "       Enables dumping of Skinny packets for debugging purposes\n";
1019
1020 static char no_debug_usage[] =
1021 "Usage: skinny no debug\n"
1022 "       Disables dumping of Skinny packets for debugging purposes\n";
1023
1024 static struct ast_cli_entry  cli_show_lines =
1025         { { "skinny", "show", "lines", NULL }, skinny_show_lines, "Show defined Skinny lines per device", show_lines_usage };
1026 static struct ast_cli_entry  cli_debug =
1027         { { "skinny", "debug", NULL }, skinny_do_debug, "Enable Skinny debugging", debug_usage };
1028 static struct ast_cli_entry  cli_no_debug =
1029         { { "skinny", "no", "debug", NULL }, skinny_no_debug, "Disable Skinny debugging", no_debug_usage };
1030
1031 static struct skinny_device *build_device(char *cat, struct ast_variable *v)
1032 {
1033         struct skinny_device *d;
1034         struct skinny_line *l;
1035         struct skinny_subchannel *sub;
1036         int i=0, y=0;
1037
1038         d = malloc(sizeof(struct skinny_device));
1039         if (d) {
1040                 memset(d, 0, sizeof(struct skinny_device));
1041                 strncpy(d->name, cat, sizeof(d->name) - 1);
1042                 while(v) {
1043                         if (!strcasecmp(v->name, "host")) {
1044                                         if (ast_get_ip(&d->addr, v->value)) {
1045                                                 free(d);
1046                                                 return NULL;
1047                                         }
1048                         } else if (!strcasecmp(v->name, "port")) {
1049                                 d->addr.sin_port = htons(atoi(v->value));
1050                         } else if (!strcasecmp(v->name, "device")) {
1051                         strncpy(d->id, v->value, sizeof(d->id)-1);
1052                         } else if (!strcasecmp(v->name, "permit") || !strcasecmp(v->name, "deny")) {
1053                                 d->ha = ast_append_ha(v->name, v->value, d->ha);
1054                         } else if (!strcasecmp(v->name, "context")) {
1055                                 strncpy(context, v->value, sizeof(context) - 1);
1056                         } else if (!strcasecmp(v->name, "version")) {
1057                                 strncpy(d->version_id, v->value, sizeof(d->version_id) -1);
1058                         } else if (!strcasecmp(v->name, "nat")) {
1059                                 nat = ast_true(v->value);
1060                         } else if (!strcasecmp(v->name, "callerid")) {
1061                                 if (!strcasecmp(v->value, "asreceived")) {
1062                                         strcpy(callerid, "");
1063                                 } else {
1064                                         strncpy(callerid, v->value, sizeof(callerid) - 1);
1065                                 }
1066                         } else if (!strcasecmp(v->name, "language")) {
1067                                 strncpy(language, v->value, sizeof(language)-1);
1068                         } else if (!strcasecmp(v->name, "accountcode")) {
1069                                 strncpy(accountcode, v->value, sizeof(accountcode)-1);
1070                         } else if (!strcasecmp(v->name, "amaflags")) {
1071                                 y = ast_cdr_amaflags2int(v->value);
1072                                 if (y < 0) {
1073                                         ast_log(LOG_WARNING, "Invalid AMA flags: %s at line %d\n", v->value, v->lineno);
1074                                 } else {
1075                                 amaflags = y;
1076                                 }
1077                         } else if (!strcasecmp(v->name, "musiconhold")) {
1078                                 strncpy(musicclass, v->value, sizeof(musicclass)-1);
1079                         } else if (!strcasecmp(v->name, "callgroup")) {
1080                                 cur_callergroup = ast_get_group(v->value);
1081                         } else if (!strcasecmp(v->name, "pickupgroup")) {
1082                                 cur_pickupgroup = ast_get_group(v->value);
1083                         } else if (!strcasecmp(v->name, "immediate")) {
1084                                 immediate = ast_true(v->value);
1085                         } else if (!strcasecmp(v->name, "cancallforward")) {
1086                                 cancallforward = ast_true(v->value);
1087                         } else if (!strcasecmp(v->name, "mailbox")) {
1088                                 strncpy(mailbox, v->value, sizeof(mailbox) -1);
1089                         } else if (!strcasecmp(v->name, "callreturn")) {
1090                                 callreturn = ast_true(v->value);
1091                         } else if (!strcasecmp(v->name, "immediate")) {
1092                                 immediate = ast_true(v->value);
1093                         } else if (!strcasecmp(v->name, "callwaiting")) {
1094                                 callwaiting = ast_true(v->value);
1095                         } else if (!strcasecmp(v->name, "transfer")) {
1096                                 transfer = ast_true(v->value);
1097                         } else if (!strcasecmp(v->name, "threewaycalling")) {
1098                                 threewaycalling = ast_true(v->value);
1099                         } else if (!strcasecmp(v->name, "linelabel")) {
1100                                 strncpy(linelabel, v->value, sizeof(linelabel)-1);
1101                         } else if (!strcasecmp(v->name, "trunk") || !strcasecmp(v->name, "line")) {
1102                                 l = malloc(sizeof(struct skinny_line));;
1103                                 if (l) {
1104                                         memset(l, 0, sizeof(struct skinny_line));
1105                                         strncpy(l->name, v->value, sizeof(l->name) - 1);
1106
1107                                         /* XXX Should we check for uniqueness?? XXX */
1108
1109                                         strncpy(l->context, context, sizeof(l->context) - 1);
1110                                         strncpy(l->callerid, callerid, sizeof(l->callerid) - 1);
1111                                         strncpy(l->label, linelabel, sizeof(l->label) - 1);
1112                                         strncpy(l->language, language, sizeof(l->language) - 1);
1113                                         strncpy(l->musicclass, musicclass, sizeof(l->musicclass)-1);
1114                                         strncpy(l->mailbox, mailbox, sizeof(l->mailbox)-1);
1115                                         strncpy(l->mailbox, mailbox, sizeof(l->mailbox)-1);
1116                                         if (!ast_strlen_zero(mailbox)) {
1117                                                 ast_verbose(VERBOSE_PREFIX_3 "Setting mailbox '%s' on %s@%s\n", mailbox, d->name, l->name);
1118                                         }
1119
1120                                         l->msgstate = -1;
1121                                         l->capability = capability;
1122                                         l->parent = d;
1123                                         if (!strcasecmp(v->name, "trunk")) {
1124                                                 l->type = TYPE_TRUNK;
1125                                         } else {
1126                                                 l->type = TYPE_LINE;
1127                                         }
1128                                         l->immediate = immediate;
1129                                         l->callgroup = cur_callergroup;
1130                                         l->pickupgroup = cur_pickupgroup;
1131                                         l->callreturn = callreturn;
1132                                         l->cancallforward = cancallforward;
1133                                         l->callwaiting = callwaiting;
1134                                         l->transfer = transfer;
1135                                         l->threewaycalling = threewaycalling;
1136                                         l->onhooktime = time(NULL);
1137                                         l->instance = 1;
1138                                         /* ASSUME we're onhook at this point*/
1139                                         l->hookstate = SKINNY_ONHOOK;
1140
1141                                         for (i = 0; i < MAX_SUBS; i++) {
1142                                                 sub = malloc(sizeof(struct skinny_subchannel));
1143                                                 if (sub) {
1144                                                         ast_verbose(VERBOSE_PREFIX_3 "Allocating Skinny subchannel '%d' on %s@%s\n", i, l->name, d->name);
1145                                                         memset(sub, 0, sizeof(struct skinny_subchannel));
1146                                                         sub->parent = l;
1147                                                         /* Make a call*ID */
1148                                                         sub->callid = callnums;
1149                                                         callnums++;
1150                                                         sub->cxmode = SKINNY_CX_INACTIVE;
1151                                                         sub->nat = nat;
1152                                                         sub->next = l->sub;
1153                                                         l->sub = sub;
1154                                                 } else {
1155                                                         /* XXX Should find a way to clean up our memory */
1156                                                         ast_log(LOG_WARNING, "Out of memory allocating subchannel");
1157                                                         return NULL;
1158                                                 }
1159                                         }
1160                                         l->next = d->lines;
1161                                         d->lines = l;
1162                                 } else {
1163                                         /* XXX Should find a way to clean up our memory */
1164                                         ast_log(LOG_WARNING, "Out of memory allocating line");
1165                                         return NULL;
1166                                 }
1167                         } else {
1168                                 ast_log(LOG_WARNING, "Don't know keyword '%s' at line %d\n", v->name, v->lineno);
1169                         }
1170                         v = v->next;
1171                 }
1172
1173                 if (!d->lines) {
1174                         ast_log(LOG_ERROR, "A Skinny device must have at least one line!\n");
1175                         return NULL;
1176                 }
1177
1178                 if (d->addr.sin_addr.s_addr && !ntohs(d->addr.sin_port))
1179                         d->addr.sin_port = htons(DEFAULT_SKINNY_PORT);
1180                 if (d->addr.sin_addr.s_addr) {
1181                         if (ast_ouraddrfor(&d->addr.sin_addr, &d->ourip)) {
1182                                 memcpy(&d->ourip, &__ourip, sizeof(d->ourip));
1183                         }
1184                 } else {
1185                         memcpy(&d->ourip, &__ourip, sizeof(d->ourip));
1186                 }
1187         }
1188         return d;
1189 }
1190
1191 static int has_voicemail(struct skinny_line *l)
1192 {
1193         return ast_app_has_voicemail(l->mailbox);
1194 }
1195
1196 static int skinny_register(skinny_req *req, struct skinnysession *s)
1197 {
1198         struct skinny_device *d;
1199
1200         ast_mutex_lock(&devicelock);
1201         d = devices;
1202         while (d) {
1203                 if (!strcasecmp(req->data.reg.name, d->id)) {
1204                         /* XXX Deal with IP authentication */
1205                         s->device = d;
1206                         d->type = req->data.reg.type;
1207                         if (ast_strlen_zero(d->version_id)) {
1208                                 strncpy(d->version_id, version_id, sizeof(d->version_id));
1209                         }
1210                         d->registered = 1;
1211                         d->session = s;
1212                         break;
1213                 }
1214                 d = d->next;
1215         }
1216         ast_mutex_unlock(&devicelock);
1217
1218         if (!d)
1219                 return 0;
1220
1221         return 1;
1222 }
1223
1224 static void start_rtp(struct skinny_subchannel *sub)
1225 {
1226                 ast_mutex_lock(&sub->lock);
1227                 /* Allocate the RTP */
1228                 sub->rtp = ast_rtp_new(sched, io, 1, 0);
1229                 if (sub->rtp && sub->owner)
1230                         sub->owner->fds[0] = ast_rtp_fd(sub->rtp);
1231                 if (sub->rtp)
1232                         ast_rtp_setnat(sub->rtp, sub->nat);
1233
1234                 /* Create the RTP connections  */
1235                 transmit_connect(sub->parent->parent->session);
1236                 ast_mutex_unlock(&sub->lock);
1237 }
1238
1239
1240 static void *skinny_ss(void *data)
1241 {
1242         struct ast_channel *chan = data;
1243         struct skinny_subchannel *sub = chan->pvt->pvt;
1244         struct skinny_line *l = sub->parent;
1245         struct skinnysession *s = l->parent->session;
1246         char exten[AST_MAX_EXTENSION] = "";
1247         int len = 0;
1248         int timeout = firstdigittimeout;
1249         int res;
1250         int getforward=0;
1251
1252         if (option_verbose > 2)
1253                 ast_verbose( VERBOSE_PREFIX_3 "Starting simple switch on '%s@%s'\n", l->name, l->parent->name);
1254
1255         while(len < AST_MAX_EXTENSION-1) {
1256         res = ast_waitfordigit(chan, timeout);
1257         timeout = 0;
1258         if (res < 0) {
1259                         if (skinnydebug)
1260                                 ast_verbose("Skinny(%s@%s): waitfordigit returned < 0\n", l->name, l->parent->name);
1261                 ast_indicate(chan, -1);
1262                         ast_hangup(chan);
1263             return NULL;
1264         } else if (res)  {
1265             exten[len++]=res;
1266             exten[len] = '\0';
1267         }
1268         if (!ast_ignore_pattern(chan->context, exten)) {
1269                         transmit_tone(s, SKINNY_SILENCE);
1270         }
1271         if (ast_exists_extension(chan, chan->context, exten, 1, l->callerid)) {
1272             if (!res || !ast_matchmore_extension(chan, chan->context, exten, 1, l->callerid)) {
1273                 if (getforward) {
1274                     /* Record this as the forwarding extension */
1275                     strncpy(l->call_forward, exten, sizeof(l->call_forward));
1276                     if (option_verbose > 2) {
1277                         ast_verbose(VERBOSE_PREFIX_3 "Setting call forward to '%s' on channel %s\n",
1278                                 l->call_forward, chan->name);
1279                     }
1280                     transmit_tone(s, SKINNY_DIALTONE);
1281                     if (res) {
1282                             break;
1283                     }
1284                     usleep(500000);
1285                     ast_indicate(chan, -1);
1286                     sleep(1);
1287                     memset(exten, 0, sizeof(exten));
1288                     transmit_tone(s, SKINNY_DIALTONE);
1289                     len = 0;
1290                     getforward = 0;
1291                 } else  {
1292                     strncpy(chan->exten, exten, sizeof(chan->exten)-1);
1293                     if (!ast_strlen_zero(l->callerid)) {
1294                         if (!l->hidecallerid)
1295                             chan->callerid = strdup(l->callerid);
1296                         chan->ani = strdup(l->callerid);
1297                     }
1298                     ast_setstate(chan, AST_STATE_RING);
1299                     res = ast_pbx_run(chan);
1300                     if (res) {
1301                         ast_log(LOG_WARNING, "PBX exited non-zero\n");
1302                                                 transmit_tone(s, SKINNY_REORDER);
1303                     }
1304                     return NULL;
1305                 }
1306             } else {
1307                 /* It's a match, but they just typed a digit, and there is an ambiguous match,
1308                    so just set the timeout to matchdigittimeout and wait some more */
1309                 timeout = matchdigittimeout;
1310             }
1311         } else if (res == 0) {
1312             ast_log(LOG_DEBUG, "Not enough digits (and no ambiguous match)...\n");
1313                 transmit_tone(s, SKINNY_REORDER);
1314             ast_hangup(chan);
1315             return NULL;
1316         } else if (l->callwaiting && !strcmp(exten, "*70")) {
1317             if (option_verbose > 2) {
1318                 ast_verbose(VERBOSE_PREFIX_3 "Disabling call waiting on %s\n", chan->name);
1319             }
1320             /* Disable call waiting if enabled */
1321             l->callwaiting = 0;
1322             transmit_tone(s, SKINNY_DIALTONE);
1323                         len = 0;
1324             memset(exten, 0, sizeof(exten));
1325             timeout = firstdigittimeout;
1326
1327         } else if (!strcmp(exten,ast_pickup_ext())) {
1328             /* Scan all channels and see if any there
1329              * ringing channqels with that have call groups
1330              * that equal this channels pickup group
1331              */
1332             if (ast_pickup_call(chan)) {
1333                 ast_log(LOG_WARNING, "No call pickup possible...\n");
1334                                 transmit_tone(s, SKINNY_REORDER);
1335             }
1336             ast_hangup(chan);
1337             return NULL;
1338
1339         } else if (!l->hidecallerid && !strcmp(exten, "*67")) {
1340             if (option_verbose > 2) {
1341                 ast_verbose(VERBOSE_PREFIX_3 "Disabling Caller*ID on %s\n", chan->name);
1342             }
1343             /* Disable Caller*ID if enabled */
1344             l->hidecallerid = 1;
1345             if (chan->callerid)
1346                 free(chan->callerid);
1347             chan->callerid = NULL;
1348             transmit_tone(s, SKINNY_DIALTONE);
1349             len = 0;
1350             memset(exten, 0, sizeof(exten));
1351             timeout = firstdigittimeout;
1352         } else if (l->callreturn && !strcmp(exten, "*69")) {
1353             res = 0;
1354             if (!ast_strlen_zero(l->lastcallerid)) {
1355                 res = ast_say_digit_str(chan, l->lastcallerid, "", chan->language);
1356             }
1357             if (!res) {
1358                 transmit_tone(s, SKINNY_DIALTONE);
1359                         }
1360             break;
1361         } else if (!strcmp(exten, "*78")) {
1362             /* Do not disturb */
1363             if (option_verbose > 2) {
1364                 ast_verbose(VERBOSE_PREFIX_3 "Enabled DND on channel %s\n", chan->name);
1365             }
1366             transmit_tone(s, SKINNY_DIALTONE);
1367             l->dnd = 1;
1368             getforward = 0;
1369             memset(exten, 0, sizeof(exten));
1370             len = 0;
1371         } else if (!strcmp(exten, "*79")) {
1372             /* Do not disturb */
1373             if (option_verbose > 2) {
1374                 ast_verbose(VERBOSE_PREFIX_3 "Disabled DND on channel %s\n", chan->name);
1375             }
1376                         transmit_tone(s, SKINNY_DIALTONE);
1377             l->dnd = 0;
1378             getforward = 0;
1379             memset(exten, 0, sizeof(exten));
1380             len = 0;
1381         } else if (l->cancallforward && !strcmp(exten, "*72")) {
1382             transmit_tone(s, SKINNY_DIALTONE);
1383             getforward = 1;
1384             memset(exten, 0, sizeof(exten));
1385             len = 0;
1386         } else if (l->cancallforward && !strcmp(exten, "*73")) {
1387             if (option_verbose > 2) {
1388                 ast_verbose(VERBOSE_PREFIX_3 "Cancelling call forwarding on channel %s\n", chan->name);
1389             }
1390             transmit_tone(s, SKINNY_DIALTONE);
1391             memset(l->call_forward, 0, sizeof(l->call_forward));
1392             getforward = 0;
1393             memset(exten, 0, sizeof(exten));
1394             len = 0;
1395         } else if (!strcmp(exten, ast_parking_ext()) &&
1396                     sub->next->owner &&
1397                     sub->next->owner->bridge) {
1398             /* This is a three way call, the main call being a real channel,
1399                 and we're parking the first call. */
1400             ast_masq_park_call(sub->next->owner->bridge, chan, 0, NULL);
1401             if (option_verbose > 2) {
1402                 ast_verbose(VERBOSE_PREFIX_3 "Parking call to '%s'\n", chan->name);
1403             }
1404             break;
1405         } else if (!ast_strlen_zero(l->lastcallerid) && !strcmp(exten, "*80")) {
1406             if (option_verbose > 2) {
1407                 ast_verbose(VERBOSE_PREFIX_3 "Blacklisting number %s\n", l->lastcallerid);
1408             }
1409             res = ast_db_put("blacklist", l->lastcallerid, "1");
1410             if (!res) {
1411                 transmit_tone(s, SKINNY_DIALTONE);
1412                 memset(exten, 0, sizeof(exten));
1413                 len = 0;
1414             }
1415         } else if (l->hidecallerid && !strcmp(exten, "*82")) {
1416             if (option_verbose > 2) {
1417                 ast_verbose(VERBOSE_PREFIX_3 "Enabling Caller*ID on %s\n", chan->name);
1418             }
1419             /* Enable Caller*ID if enabled */
1420             l->hidecallerid = 0;
1421             if (chan->callerid)
1422                 free(chan->callerid);
1423             if (!ast_strlen_zero(l->callerid))
1424                 chan->callerid = strdup(l->callerid);
1425             transmit_tone(s, SKINNY_DIALTONE);
1426             len = 0;
1427             memset(exten, 0, sizeof(exten));
1428             timeout = firstdigittimeout;
1429         } else if (!ast_canmatch_extension(chan, chan->context, exten, 1, chan->callerid) &&
1430                         ((exten[0] != '*') || (!ast_strlen_zero(exten) > 2))) {
1431             ast_log(LOG_WARNING, "Can't match [%s] from '%s' in context %s\n", exten, chan->callerid ? chan->callerid : "<Unknown Caller>", chan->context);
1432             transmit_tone(s, SKINNY_REORDER);
1433                         sleep(3); // hang out for 3 seconds to let congestion play
1434                         break;
1435         }
1436         if (!timeout)
1437             timeout = gendigittimeout;
1438         if (len && !ast_ignore_pattern(chan->context, exten))
1439                         ast_indicate(chan, -1);
1440     }
1441         ast_hangup(chan);
1442         return NULL;
1443 }
1444
1445
1446
1447 static int skinny_call(struct ast_channel *ast, char *dest, int timeout)
1448 {
1449         int res = 0;
1450         int tone = 0;
1451         struct skinny_line *l;
1452     struct skinny_subchannel *sub;
1453         struct skinnysession *session;
1454
1455         sub = ast->pvt->pvt;
1456     l = sub->parent;
1457         session = l->parent->session;
1458
1459         if (!l->parent->registered) {
1460                 ast_log(LOG_ERROR, "Device not registered, cannot call %s\n", dest);
1461                 return -1;
1462         }
1463
1464         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1465                 ast_log(LOG_WARNING, "skinny_call called on %s, neither down nor reserved\n", ast->name);
1466                 return -1;
1467         }
1468
1469     if (skinnydebug) {
1470         ast_verbose(VERBOSE_PREFIX_3 "skinny_call(%s)\n", ast->name);
1471     }
1472
1473         if (l->dnd) {
1474                 ast_queue_control(ast, AST_CONTROL_BUSY);
1475                 return -1;
1476         }
1477
1478         switch (l->hookstate) {
1479         case SKINNY_OFFHOOK:
1480             tone = SKINNY_CALLWAITTONE;
1481             break;
1482         case SKINNY_ONHOOK:
1483                         tone = SKINNY_ALERT;
1484                         break;
1485         default:
1486             ast_log(LOG_ERROR, "Don't know how to deal with hookstate %d\n", l->hookstate);
1487             break;
1488     }
1489
1490         transmit_lamp_indication(session, l->instance, SKINNY_LAMP_BLINK);
1491         transmit_ringer_mode(session, SKINNY_RING_INSIDE);
1492         transmit_tone(session, tone);
1493         transmit_callstate(session, l->instance, SKINNY_RINGIN, sub->callid);
1494
1495 // Set the prompt
1496 // Select the active softkeys
1497
1498         ast_setstate(ast, AST_STATE_RINGING);
1499         ast_queue_control(ast, AST_CONTROL_RINGING);
1500
1501         sub->outgoing = 1;
1502 //    sub->cxmode = SKINNY_CX_RECVONLY;
1503         if (l->type == TYPE_LINE) {
1504         if (!sub->rtp) {
1505             start_rtp(sub);
1506         } else {
1507                         /* do we need to anything if there already is an RTP allocated? */
1508 //           transmit_modify_request(sub);
1509         }
1510
1511 #if 0
1512         if (sub->next->owner && sub->next->callid) {
1513             /* try to prevent a callwait from disturbing the other connection */
1514             sub->next->cxmode = SKINNY_CX_RECVONLY;
1515       //      transmit_modify_request(sub->next);
1516         }
1517
1518                 /* not sure what this doing */
1519                 if (sub->next->owner && sub->next->callid) {
1520             /* Put the connection back in sendrecv */
1521             sub->next->cxmode = SKINNY_CX_SENDRECV;
1522 //           transmit_modify_request(sub->next);
1523         }
1524 #endif
1525
1526         } else {
1527                 ast_log(LOG_NOTICE, "Don't know how to dial on trunks yet\n");
1528                 res = -1;
1529         }
1530         return res;
1531 }
1532
1533
1534 static int skinny_hangup(struct ast_channel *ast)
1535 {
1536     struct skinny_subchannel *sub = ast->pvt->pvt;
1537     struct skinny_line *l = sub->parent;
1538         struct skinnysession *s = l->parent->session;
1539
1540     if (skinnydebug) {
1541         ast_verbose("skinny_hangup(%s) on %s@%s\n", ast->name, l->name, l->parent->name);
1542     }
1543     if (!ast->pvt->pvt) {
1544         ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
1545         return 0;
1546     }
1547
1548         if (l->parent->registered) {
1549                     if ((sub->parent->type = TYPE_LINE) && (sub->parent->hookstate == SKINNY_OFFHOOK)) {
1550                         sub->parent->hookstate = SKINNY_ONHOOK;
1551                         transmit_callstate(s, l->instance, SKINNY_ONHOOK, sub->callid);
1552                         transmit_speaker_mode(s, SKINNY_SPEAKEROFF);
1553                 } else if ((sub->parent->type = TYPE_LINE) && (sub->parent->hookstate == SKINNY_ONHOOK)) {
1554                         transmit_callstate(s, l->instance, SKINNY_ONHOOK, sub->callid);
1555                         transmit_speaker_mode(s, SKINNY_SPEAKEROFF);
1556                         transmit_ringer_mode(s, SKINNY_RING_OFF);
1557                         transmit_tone(s, SKINNY_SILENCE);
1558                 }
1559         }
1560     ast_mutex_lock(&sub->lock);
1561     sub->owner = NULL;
1562     ast->pvt->pvt = NULL;
1563     sub->alreadygone = 0;
1564     sub->outgoing = 0;
1565     sub->cxmode = SKINNY_CX_INACTIVE;
1566     if (sub->rtp) {
1567         ast_rtp_destroy(sub->rtp);
1568         sub->rtp = NULL;
1569     }
1570     ast_mutex_unlock(&sub->lock);
1571     return 0;
1572 }
1573
1574 static int skinny_answer(struct ast_channel *ast)
1575 {
1576         int res = 0;
1577         struct skinny_subchannel *sub = ast->pvt->pvt;
1578         struct skinny_line *l = sub->parent;
1579     sub->cxmode = SKINNY_CX_SENDRECV;
1580     if (!sub->rtp) {
1581                 start_rtp(sub);
1582     } else {
1583 //        transmit_modify_request(sub);
1584     }
1585     ast_verbose("skinny_answer(%s) on %s@%s-%d\n", ast->name, l->name, l->parent->name, sub->callid);
1586         if (ast->_state != AST_STATE_UP) {
1587                 ast_setstate(ast, AST_STATE_UP);
1588
1589 //              transmit_notify_request(sub, "");
1590 //              transmit_modify_request(sub);
1591         }
1592         return res;
1593 }
1594
1595 static struct ast_frame *skinny_rtp_read(struct skinny_subchannel *sub)
1596 {
1597         /* Retrieve audio/etc from channel.  Assumes sub->lock is already held. */
1598         struct ast_frame *f;
1599         f = ast_rtp_read(sub->rtp);
1600         if (sub->owner) {
1601                 /* We already hold the channel lock */
1602                 if (f->frametype == AST_FRAME_VOICE) {
1603                         if (f->subclass != sub->owner->nativeformats) {
1604                                 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
1605                                 sub->owner->nativeformats = f->subclass;
1606                                 ast_set_read_format(sub->owner, sub->owner->readformat);
1607                                 ast_set_write_format(sub->owner, sub->owner->writeformat);
1608                         }
1609                 }
1610         }
1611         return f;
1612 }
1613
1614
1615 static struct ast_frame  *skinny_read(struct ast_channel *ast)
1616 {
1617         struct ast_frame *fr;
1618         struct skinny_subchannel *sub = ast->pvt->pvt;
1619         ast_mutex_lock(&sub->lock);
1620         fr = skinny_rtp_read(sub);
1621         ast_mutex_unlock(&sub->lock);
1622         return fr;
1623 }
1624
1625 static int skinny_write(struct ast_channel *ast, struct ast_frame *frame)
1626 {
1627         struct skinny_subchannel *sub = ast->pvt->pvt;
1628         int res = 0;
1629         if (frame->frametype != AST_FRAME_VOICE) {
1630                 if (frame->frametype == AST_FRAME_IMAGE)
1631                         return 0;
1632                 else {
1633                         ast_log(LOG_WARNING, "Can't send %d type frames with SKINNY write\n", frame->frametype);
1634                         return 0;
1635                 }
1636         } else {
1637                 if (!(frame->subclass & ast->nativeformats)) {
1638                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
1639                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
1640                         return -1;
1641                 }
1642         }
1643         if (sub) {
1644                 ast_mutex_lock(&sub->lock);
1645                 if (sub->rtp) {
1646                         res =  ast_rtp_write(sub->rtp, frame);
1647                 }
1648                 ast_mutex_unlock(&sub->lock);
1649         }
1650         return res;
1651 }
1652
1653 static int skinny_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
1654 {
1655         struct skinny_subchannel *sub = newchan->pvt->pvt;
1656     ast_log(LOG_NOTICE, "skinny_fixup(%s, %s)\n", oldchan->name, newchan->name);
1657         if (sub->owner != oldchan) {
1658                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, sub->owner);
1659                 return -1;
1660         }
1661         sub->owner = newchan;
1662         return 0;
1663 }
1664
1665 static int skinny_senddigit(struct ast_channel *ast, char digit)
1666 {
1667 //      struct skinny_subchannel *sub = ast->pvt->pvt;
1668 //      int tmp;
1669 //      sprintf(tmp, "%d", digit);  // not right
1670 //      transmit_tone(sub->parent->parent->session, digit);
1671         return -1;
1672 }
1673
1674 static char *control2str(int ind) {
1675     switch (ind) {
1676         case AST_CONTROL_HANGUP:
1677             return "Other end has hungup";
1678         case AST_CONTROL_RING:
1679             return "Local ring";
1680         case AST_CONTROL_RINGING:
1681             return "Remote end is ringing";
1682         case AST_CONTROL_ANSWER:
1683             return "Remote end has answered";
1684         case AST_CONTROL_BUSY:
1685             return "Remote end is busy";
1686         case AST_CONTROL_TAKEOFFHOOK:
1687             return "Make it go off hook";
1688         case AST_CONTROL_OFFHOOK:
1689             return "Line is off hook";
1690         case AST_CONTROL_CONGESTION:
1691             return "Congestion (circuits busy)";
1692         case AST_CONTROL_FLASH:
1693             return "Flash hook";
1694         case AST_CONTROL_WINK:
1695             return "Wink";
1696         case AST_CONTROL_OPTION:
1697             return "Set a low-level option";
1698         case AST_CONTROL_RADIO_KEY:
1699             return "Key Radio";
1700         case AST_CONTROL_RADIO_UNKEY:
1701             return "Un-Key Radio";
1702                 case -1:
1703                         return "Stop tone";
1704     }
1705     return "UNKNOWN";
1706 }
1707
1708
1709 static int skinny_indicate(struct ast_channel *ast, int ind)
1710 {
1711         struct skinny_subchannel *sub = ast->pvt->pvt;
1712         struct skinny_line *l = sub->parent;
1713         struct skinnysession *s = l->parent->session;
1714
1715     if (skinnydebug) {
1716         ast_verbose(VERBOSE_PREFIX_3 "Asked to indicate '%s' condition on channel %s\n", control2str(ind), ast->name);
1717     }
1718         switch(ind) {
1719         case AST_CONTROL_RINGING:
1720                 transmit_tone(s, SKINNY_ALERT);
1721                 transmit_callstate(s, l->instance, SKINNY_PROGRESS, sub->callid);
1722                 break;
1723         case AST_CONTROL_BUSY:
1724                 transmit_tone(s, SKINNY_BUSYTONE);
1725                 transmit_callstate(s, l->instance, SKINNY_BUSY, sub->callid);
1726                 break;
1727         case AST_CONTROL_CONGESTION:
1728                 transmit_tone(s, SKINNY_REORDER);
1729                 transmit_callstate(s, l->instance, SKINNY_CONGESTION, sub->callid);
1730                 break;
1731         case -1:
1732                 transmit_tone(s, SKINNY_SILENCE);
1733                 break;
1734         default:
1735                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", ind);
1736                 return -1;
1737         }
1738         return 0;
1739 }
1740
1741 static struct ast_channel *skinny_new(struct skinny_subchannel *sub, int state)
1742 {
1743         struct ast_channel *tmp;
1744         struct skinny_line *l = sub->parent;
1745         int fmt;
1746         l = sub->parent;
1747         tmp = ast_channel_alloc(1);
1748         if (tmp) {
1749                 tmp->nativeformats = l->capability;
1750                 if (!tmp->nativeformats)
1751                         tmp->nativeformats = capability;
1752                 fmt = ast_best_codec(tmp->nativeformats);
1753                 snprintf(tmp->name, sizeof(tmp->name), "Skinny/%s@%s-%d", l->name, l->parent->name, sub->callid);
1754                 if (sub->rtp)
1755                         tmp->fds[0] = ast_rtp_fd(sub->rtp);
1756                 tmp->type = type;
1757                 ast_setstate(tmp, state);
1758                 if (state == AST_STATE_RING)
1759                         tmp->rings = 1;
1760                 tmp->writeformat = fmt;
1761                 tmp->pvt->rawwriteformat = fmt;
1762                 tmp->readformat = fmt;
1763                 tmp->pvt->rawreadformat = fmt;
1764                 tmp->pvt->pvt = sub;
1765                 tmp->pvt->call = skinny_call;
1766                 tmp->pvt->hangup = skinny_hangup;
1767                 tmp->pvt->answer = skinny_answer;
1768                 tmp->pvt->read = skinny_read;
1769                 tmp->pvt->write = skinny_write;
1770                 tmp->pvt->indicate = skinny_indicate;
1771                 tmp->pvt->fixup = skinny_fixup;
1772                 tmp->pvt->send_digit = skinny_senddigit;
1773 //              tmp->pvt->bridge = ast_rtp_bridge;
1774                 if (!ast_strlen_zero(l->language))
1775                         strncpy(tmp->language, l->language, sizeof(tmp->language)-1);
1776                 if (!ast_strlen_zero(l->accountcode))
1777                         strncpy(tmp->accountcode, l->accountcode, sizeof(tmp->accountcode)-1);
1778                 if (l->amaflags)
1779                         tmp->amaflags = l->amaflags;
1780                 sub->owner = tmp;
1781                 ast_mutex_lock(&usecnt_lock);
1782                 usecnt++;
1783                 ast_mutex_unlock(&usecnt_lock);
1784                 ast_update_use_count();
1785                 tmp->callgroup = l->callgroup;
1786                 tmp->pickupgroup = l->pickupgroup;
1787                 strncpy(tmp->call_forward, l->call_forward, sizeof(tmp->call_forward));
1788                 strncpy(tmp->context, l->context, sizeof(tmp->context)-1);
1789                 strncpy(tmp->exten,l->exten, sizeof(tmp->exten)-1);
1790                 if (!ast_strlen_zero(l->callerid))
1791                         tmp->callerid = strdup(l->callerid);
1792                 tmp->priority = 1;
1793                 if (state != AST_STATE_DOWN) {
1794                         if (ast_pbx_start(tmp)) {
1795                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
1796                                 ast_hangup(tmp);
1797                                 tmp = NULL;
1798                         }
1799                 }
1800         } else {
1801                 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
1802     }
1803
1804         return tmp;
1805 }
1806
1807 static int handle_message(skinny_req *req, struct skinnysession *s)
1808 {
1809         struct skinny_subchannel *sub;
1810         struct ast_channel *c;
1811         struct ast_frame f = { 0, };
1812         struct sockaddr_in sin;
1813         struct sockaddr_in us;
1814         struct skinny_line *lines;
1815         char name[16];
1816         char addr[4];
1817         char d;
1818         int digit;
1819         int res=0;
1820         int speedDialNum;
1821         int lineNumber;
1822         int stimulus;
1823         int stimulusInstance;
1824         int status;
1825         int port;
1826         int i;
1827         time_t timer;
1828         struct tm *cmtime;
1829         pthread_t t;
1830
1831         if ( (!s->device) && (req->e != REGISTER_MESSAGE && req->e != ALARM_MESSAGE)) {
1832                 ast_log(LOG_WARNING, "Client sent message #%d without first registering.\n", req->e);
1833                 free(req);
1834                 return 0;
1835         }
1836
1837
1838         switch(req->e)  {
1839         case ALARM_MESSAGE:
1840                 if (skinnydebug)
1841                         ast_verbose("Recieved AlarmMessage\n");
1842                 break;
1843         case REGISTER_MESSAGE:
1844                 if (skinnydebug)
1845                         ast_verbose("Device %s is attempting to register\n", req->data.reg.name);
1846                 res = skinny_register(req, s);
1847                 if (!res) {
1848                         ast_log(LOG_ERROR, "Rejecting Device %s: Device not found\n", req->data.reg.name);
1849                         memcpy(&name, req->data.reg.name, sizeof(req->data.reg.name));
1850                         memset(req, 0, sizeof(skinny_req));
1851                         req->len = sizeof(register_rej_message)+4;
1852                         req->e = REGISTER_REJ_MESSAGE;
1853                         sprintf(req->data.regrej.errMsg, "No Authority: %s", name);
1854                         transmit_response(s, req);
1855                         break;
1856                 }
1857                 if (option_verbose > 2)
1858                         ast_verbose(VERBOSE_PREFIX_3 "Device '%s' successfuly registered\n", s->device->name);
1859                 memset(req, 0, SKINNY_MAX_PACKET);
1860                 req->len = sizeof(register_ack_message)+4;
1861                 req->e = REGISTER_ACK_MESSAGE;
1862                 strcpy(req->data.regack.res, "0");
1863                 req->data.regack.keepAlive = keep_alive;
1864                 strcpy(req->data.regack.dateTemplate, date_format);
1865                 strcpy(req->data.regack.res2, "0");
1866                 req->data.regack.secondaryKeepAlive = keep_alive;
1867                 transmit_response(s, req);
1868                 if (skinnydebug)
1869                         ast_verbose("Requesting capabilities\n");
1870                 memset(req, 0, SKINNY_MAX_PACKET);
1871                 req->len = 4;
1872                 req->e = CAPABILITIES_REQ_MESSAGE;
1873                 transmit_response(s, req);
1874                 break;
1875         case UNREGISTER_MESSAGE:
1876                 /* XXX Acutally unregister the device */
1877                 break;
1878         case IP_PORT_MESSAGE:
1879                 break;
1880         case STIMULUS_MESSAGE:
1881                 stimulus = req->data.stimulus.stimulus;
1882                 stimulusInstance = req->data.stimulus.stimulusInstance;
1883
1884                 switch(stimulus) {
1885                 case STIMULUS_REDIAL:
1886                         // XXX how we gonna deal with redial ?!?!
1887                         if (skinnydebug) {
1888                                 ast_verbose("Recieved Stimulus: Redial(%d)\n", stimulusInstance);
1889                         }
1890                         break;
1891                 case STIMULUS_SPEEDDIAL:
1892                         if (skinnydebug) {
1893                                 ast_verbose("Recieved Stimulus: SpeedDial(%d)\n", stimulusInstance);
1894                         }
1895                         break;
1896                 case STIMULUS_HOLD:
1897                         // Easy enough
1898                         if (skinnydebug) {
1899                                 ast_verbose("Recieved Stimulus: Hold(%d)\n", stimulusInstance);
1900                         }
1901                         break;
1902                 case STIMULUS_TRANSFER:
1903                         if (skinnydebug) {
1904                                 ast_verbose("Recieved Stimulus: Transfer(%d)\n", stimulusInstance);
1905                         }
1906                         transmit_tone(s, SKINNY_DIALTONE);
1907
1908                         // figure out how to transfer
1909
1910                         break;
1911                 case STIMULUS_FORWARDALL:
1912                 case STIMULUS_FORWARDBUSY:
1913                 case STIMULUS_FORWARDNOANSWER:
1914                         // Gonna be fun
1915                         if (skinnydebug) {
1916                                 ast_verbose("Recieved Stimulus: Forward (%d)\n", stimulusInstance);
1917                         }
1918                         break;
1919                 case STIMULUS_DISPLAY:
1920                         // XXX Not sure
1921                         if (skinnydebug) {
1922                                 ast_verbose("Recieved Stimulus: Display(%d)\n", stimulusInstance);
1923                         }
1924                         break;
1925                 case STIMULUS_LINE:
1926                         if (skinnydebug) {
1927                                 ast_verbose("Recieved Stimulus: Line(%d)\n", stimulusInstance);
1928                         }
1929                         sub = find_subchannel_by_line(s->device->lines);
1930                         transmit_speaker_mode(s, 1);  // Turn on
1931                 break;
1932                 default:
1933                         ast_verbose("RECEIVED UNKNOWN STIMULUS:  %d(%d)\n", stimulus, stimulusInstance);
1934                         break;
1935                 }
1936
1937
1938                 break;
1939         case VERSION_REQ_MESSAGE:
1940                 if (skinnydebug)
1941                         ast_verbose("Version Request\n");
1942                 memset(req, 0, SKINNY_MAX_PACKET);
1943                 req->len = sizeof(version_res_message)+4;
1944                 req->e = VERSION_RES_MESSAGE;
1945                 sprintf(req->data.version.version, s->device->version_id);
1946                 transmit_response(s, req);
1947                 break;
1948         case SERVER_REQUEST_MESSAGE:
1949                 if (skinnydebug)
1950                         ast_verbose("Recieved Server Request\n");
1951                 memset(req, 0, SKINNY_MAX_PACKET);
1952                 req->len = sizeof(server_res_message)+4;
1953                 req->e = SERVER_RES_MESSAGE;
1954                 memcpy(req->data.serverres.server[0].serverName, ourhost,
1955                                 sizeof(req->data.serverres.server[0].serverName));
1956                 req->data.serverres.serverListenPort[0] = ourport;
1957                 req->data.serverres.serverIpAddr[0] = __ourip.s_addr;
1958                 transmit_response(s, req);
1959                 break;
1960         case BUTTON_TEMPLATE_REQ_MESSAGE:
1961                 if (skinnydebug)
1962                         ast_verbose("Buttontemplate requested\n");
1963                 memset(req, 0, SKINNY_MAX_PACKET);
1964                 req->len = sizeof(button_template_res_message)+4;
1965                 req->e = BUTTON_TEMPLATE_RES_MESSAGE;
1966                 req->data.buttontemplate.buttonOffset           = 0;
1967                 req->data.buttontemplate.buttonCount            = 10;
1968                 req->data.buttontemplate.totalButtonCount       = 10;
1969                 /* XXX Figure out how to do this correctly */
1970                 memcpy(req->data.buttontemplate.definition,
1971                            button_definition_hack,
1972                            sizeof(req->data.buttontemplate.definition));
1973                 transmit_response(s, req);
1974                 break;
1975         case SOFT_KEY_SET_REQ_MESSAGE:
1976                 if (skinnydebug)
1977                         ast_verbose("Received SoftKeySetReq\n");
1978                 memset(req, 0, SKINNY_MAX_PACKET);
1979                 req->len = sizeof(soft_key_sets)+4;
1980                 req->e = SOFT_KEY_SET_RES_MESSAGE;
1981                 req->data.softkeysets.softKeySetOffset          = 0;
1982                 req->data.softkeysets.softKeySetCount           = 11;
1983                 req->data.softkeysets.totalSoftKeySetCount  = 11;
1984                 /* XXX Wicked hack XXX */
1985                 memcpy(req->data.softkeysets.softKeySetDefinition,
1986                            soft_key_set_hack,
1987                            sizeof(req->data.softkeysets.softKeySetDefinition));
1988                 transmit_response(s,req);
1989                 break;
1990         case SOFT_KEY_TEMPLATE_REQ_MESSAGE:
1991                 if (skinnydebug)
1992                         ast_verbose("Recieved SoftKey Template Request\n");
1993                 memset(req, 0, SKINNY_MAX_PACKET);
1994                 req->len = sizeof(soft_key_template)+4;
1995                 req->e = SOFT_KEY_TEMPLATE_RES_MESSAGE;
1996                 req->data.softkeytemplate.softKeyOffset         = 0;
1997                 req->data.softkeytemplate.softKeyCount          = 21;
1998                 req->data.softkeytemplate.totalSoftKeyCount = 21;
1999                 /* XXX Another wicked hack XXX */
2000                 memcpy(req->data.softkeytemplate.softKeyTemplateDefinition,
2001                            soft_key_template_hack,
2002                            sizeof(req->data.softkeytemplate.softKeyTemplateDefinition));
2003                 transmit_response(s,req);
2004                 break;
2005         case TIME_DATE_REQ_MESSAGE:
2006                 if (skinnydebug)
2007                         ast_verbose("Received Time/Date Request\n");
2008                 memset(req, 0, SKINNY_MAX_PACKET);
2009                 req->len = sizeof(definetimedate_message)+4;
2010                 req->e = DEFINETIMEDATE_MESSAGE;
2011                 timer=time(NULL);
2012                 cmtime = localtime(&timer);
2013                 req->data.definetimedate.year = cmtime->tm_year+1900;
2014                 req->data.definetimedate.month = cmtime->tm_mon+1;
2015                 req->data.definetimedate.dayofweek = cmtime->tm_wday;
2016                 req->data.definetimedate.day = cmtime->tm_mday;
2017                 req->data.definetimedate.hour = cmtime->tm_hour;
2018                 req->data.definetimedate.minute = cmtime->tm_min;
2019                 req->data.definetimedate.seconds = cmtime->tm_sec;
2020                 transmit_response(s, req);
2021                 break;
2022         case SPEED_DIAL_STAT_REQ_MESSAGE:
2023                 /* Not really sure how Speed Dial's are different than the
2024                    Softkey templates */
2025                 speedDialNum = req->data.speeddialreq.speedDialNumber;
2026 //              if (skinnydebug)
2027 //                      ast_verbose("Recieved SpeedDialStatReq: %d\n", speedDialNum);
2028                 memset(req, 0, SKINNY_MAX_PACKET);
2029                 req->len = sizeof(speed_dial_stat_res_message)+4;
2030                 req->e = SPEED_DIAL_STAT_RES_MESSAGE;
2031 #if 0
2032                 /* XXX Do this right XXX */
2033                 req->data.speeddialreq.speedDialNumber = speedDialNum;
2034                 sprintf(req->data.speeddial.speedDialDirNumber, "31337");
2035                 sprintf(req->data.speeddial.speedDialDisplayName, "Asterisk Rules!");
2036 #endif
2037                 transmit_response(s, req);
2038                 break;
2039         case LINE_STATE_REQ_MESSAGE:
2040                 lineNumber = req->data.line.lineNumber;
2041                 if (skinnydebug)
2042                         ast_verbose("Received LineStateReq\n");
2043                 memset(req, 0, SKINNY_MAX_PACKET);
2044                 req->len = sizeof(line_stat_res_message)+4;
2045                 req->e = LINE_STAT_RES_MESSAGE;
2046                 sub = find_subchannel_by_line(s->device->lines);
2047                 if (!sub) {
2048                         ast_log(LOG_NOTICE, "No available lines on: %s\n", s->device->name);
2049                         return 0;
2050                 }
2051                 lines = sub->parent;
2052                 ast_mutex_lock(&devicelock);
2053                 for (i=1; i < lineNumber; i++) {
2054                         lines = lines->next;
2055                 }
2056                 ast_mutex_unlock(&devicelock);
2057                 req->data.linestat.linenumber = lineNumber;
2058                 memcpy(req->data.linestat.lineDirNumber, lines->name,
2059                                 sizeof(req->data.linestat.lineDirNumber));
2060                 memcpy(req->data.linestat.lineDisplayName, lines->label,
2061                                 sizeof(req->data.linestat.lineDisplayName));
2062                 transmit_response(s,req);
2063                 break;
2064         case CAPABILITIES_RES_MESSAGE:
2065                 if (skinnydebug)
2066                         ast_verbose("Received CapabilitiesRes\n");
2067                 // zien wat ie kan en verwerken (handshake)
2068                 break;
2069         case KEEP_ALIVE_MESSAGE:
2070                 memset(req, 0, SKINNY_MAX_PACKET);
2071                 req->len = 4;
2072                 req->e = KEEP_ALIVE_ACK_MESSAGE;
2073                 transmit_response(s, req);
2074                 break;
2075         case OFFHOOK_MESSAGE:
2076                 transmit_ringer_mode(s,SKINNY_RING_OFF);
2077                 transmit_lamp_indication(s, s->device->lines->instance, SKINNY_LAMP_ON);
2078
2079                 sub = find_subchannel_by_line(s->device->lines);
2080                 if (!sub) {
2081                         ast_log(LOG_NOTICE, "No available lines on: %s\n", s->device->name);
2082                         return 0;
2083                 }
2084                 sub->parent->hookstate = SKINNY_OFFHOOK;
2085
2086                         if (sub->outgoing) {
2087                                 transmit_callstate(s, s->device->lines->instance, SKINNY_OFFHOOK, sub->callid);
2088                                 transmit_tone(s, SKINNY_SILENCE);
2089                                 ast_setstate(sub->owner, AST_STATE_UP);
2090                                 // select soft keys
2091                         } else {
2092                                 if (!sub->owner) {
2093
2094                                         transmit_callstate(s, s->device->lines->instance, SKINNY_OFFHOOK, sub->callid);
2095                                         transmit_tone(s, SKINNY_DIALTONE);
2096                                         c = skinny_new(sub, AST_STATE_DOWN);
2097                                         if(c) {
2098                                                 /* start switch */
2099                                                 if (pthread_create(&t, NULL, skinny_ss, c)) {
2100                                                         ast_log(LOG_WARNING, "Unable to create switch thread: %s\n", strerror(errno));
2101                                                         ast_hangup(c);
2102                                                 }
2103                                         } else {
2104                                                 ast_log(LOG_WARNING, "Unable to create channel for %s@%s\n", sub->parent->name, s->device->name);
2105                                         }
2106
2107                                 } else {
2108                                         ast_log(LOG_DEBUG, "Current sub [%s] already has owner\n", sub->owner->name);
2109                                 }
2110                         }
2111                 break;
2112         case ONHOOK_MESSAGE:
2113                 sub = find_subchannel_by_line(s->device->lines);
2114                 if (sub->parent->hookstate == SKINNY_ONHOOK) {
2115                         /* Somthing else already put us back on hook */
2116                         break;
2117                 }
2118                 sub->cxmode = SKINNY_CX_RECVONLY;
2119                 sub->parent->hookstate = SKINNY_ONHOOK;
2120                 transmit_callstate(s, s->device->lines->instance, sub->parent->hookstate,sub->callid);
2121             if (skinnydebug)
2122                         ast_verbose("Skinny %s@%s went on hook\n",sub->parent->name, sub->parent->parent->name);
2123             if (sub->rtp) {
2124  //         transmit_modify_request(sub);
2125         }
2126         if (sub->parent->transfer && (sub->owner && sub->next->owner) && ((!sub->outgoing) || (!sub->next->outgoing))) {
2127                         /* We're allowed to transfer, we have two active calls and */
2128                         /* we made at least one of the calls.  Let's try and transfer */
2129 #if 0
2130              if ((res = attempt_transfer(p)) < 0) {
2131                                  if (p->sub->next->owner) {
2132                                         sub->next->alreadygone = 1;
2133                                         ast_queue_hangup(sub->next->owner,1);
2134                                 }
2135                          } else if (res) {
2136                                     ast_log(LOG_WARNING, "Transfer attempt failed\n");
2137                                         return -1;
2138              }
2139 #endif
2140        } else {
2141            /* Hangup the current call */
2142            /* If there is another active call, skinny_hangup will ring the phone with the other call */
2143            if (sub->owner) {
2144                sub->alreadygone = 1;
2145                ast_queue_hangup(sub->owner);
2146            } else {
2147                ast_log(LOG_WARNING, "Skinny(%s@%s-%d) channel already destroyed\n",
2148                            sub->parent->name, sub->parent->parent->name, sub->callid);
2149            }
2150        }
2151        if ((sub->parent->hookstate == SKINNY_ONHOOK) && (!sub->rtp) && (!sub->next->rtp)) {
2152                         if (has_voicemail(sub->parent)) {
2153                                 transmit_lamp_indication(s, s->device->lines->instance, SKINNY_LAMP_FLASH);
2154             } else {
2155                                 transmit_lamp_indication(s, s->device->lines->instance, SKINNY_LAMP_OFF);
2156             }
2157        }
2158            break;
2159         case KEYPAD_BUTTON_MESSAGE:
2160                 digit = req->data.keypad.button;
2161                 if (skinnydebug) {
2162                         ast_verbose("Collected digit: [%d]\n", digit);
2163                 }
2164                 f.frametype = AST_FRAME_DTMF;
2165                 if (digit == 14) {
2166                         sprintf(&d, "*");
2167                 } else if (digit == 15) {
2168                         sprintf(&d, "#");
2169                 } else {
2170                         sprintf(&d, "%d", digit);
2171                 }
2172                 f.subclass  = d;
2173                 f.src = "skinny";
2174
2175                 sub = find_subchannel_by_line(s->device->lines);
2176
2177                 if (sub->owner) {
2178                         /* XXX MUST queue this frame to all subs in threeway call if threeway call is active */
2179                         ast_queue_frame(sub->owner, &f);
2180             if (sub->next->owner) {
2181                                 ast_queue_frame(sub->next->owner, &f);
2182             }
2183         } else {
2184                         ast_verbose("No owner: %s\n", s->device->lines->name);
2185                 }
2186                 break;
2187         case OPEN_RECIEVE_CHANNEL_ACK_MESSAGE:
2188                 ast_verbose("Recieved Open Recieve Channel Ack\n");
2189                 status = req->data.openrecievechannelack.status;
2190                 if (status) {
2191                         ast_log(LOG_ERROR, "Open Recieve Channel Failure\n");
2192                         break;
2193                 }
2194                 memcpy(addr, req->data.openrecievechannelack.ipAddr, sizeof(addr));
2195                 port = req->data.openrecievechannelack.port;
2196
2197                 sin.sin_family = AF_INET;
2198                 memcpy(&sin.sin_addr, addr, sizeof(sin.sin_addr));  // Endian?
2199                 sin.sin_port = htons(port);
2200
2201                 sub = find_subchannel_by_line(s->device->lines);
2202                 if (sub->rtp) {
2203                         ast_rtp_set_peer(sub->rtp, &sin);
2204                         ast_rtp_get_us(sub->rtp, &us);
2205                 } else {
2206                         ast_log(LOG_ERROR, "No RTP structure, this is very bad\n");
2207                         break;
2208                 }
2209                 memset(req, 0, SKINNY_MAX_PACKET);
2210                 req->len = sizeof(start_media_transmission_message)+4;
2211                 req->e = START_MEDIA_TRANSMISSION_MESSAGE;
2212                 req->data.startmedia.conferenceId = 0;
2213                 req->data.startmedia.passThruPartyId = 0;
2214                 memcpy(req->data.startmedia.remoteIp, &s->device->ourip, 4); // Endian?
2215                 req->data.startmedia.remotePort = ntohs(us.sin_port);
2216                 req->data.startmedia.packetSize = 20;
2217                 req->data.startmedia.payloadType = convert_cap(s->device->lines->capability);
2218                 req->data.startmedia.qualifier.precedence = 127;
2219                 req->data.startmedia.qualifier.vad = 0;
2220                 req->data.startmedia.qualifier.packets = 0;
2221                 req->data.startmedia.qualifier.bitRate = 0;
2222                 transmit_response(s, req);
2223                 break;
2224         default:
2225                 ast_verbose("RECEIVED UNKNOWN MESSAGE TYPE:  %x\n", req->e);
2226                 break;
2227         }
2228
2229         free(req);
2230         return 1;
2231
2232 }
2233
2234 static void destroy_session(struct skinnysession *s)
2235 {
2236         struct skinnysession *cur, *prev = NULL;
2237         ast_mutex_lock(&sessionlock);
2238         cur = sessions;
2239         while(cur) {
2240                 if (cur == s)
2241                         break;
2242                 prev = cur;
2243                 cur = cur->next;
2244         }
2245         if (cur) {
2246                 if (prev)
2247                         prev->next = cur->next;
2248                 else
2249                         sessions = cur->next;
2250                 if (s->fd > -1)
2251                         close(s->fd);
2252                 free(s);
2253         } else
2254                 ast_log(LOG_WARNING, "Trying to delete non-existant session %p?\n", s);
2255         ast_mutex_unlock(&sessionlock);
2256 }
2257
2258 static int get_input(struct skinnysession *s)
2259 {
2260
2261         int res;
2262         int dlen = 0;
2263         struct pollfd fds[1];
2264
2265         fds[0].fd = s->fd;
2266         fds[0].events = POLLIN;
2267         res = poll(fds, 1, -1);
2268
2269         if (res < 0) {
2270                 ast_log(LOG_WARNING, "Select returned error: %s\n", strerror(errno));
2271         } else if (res > 0) {
2272                 memset(s->inbuf,0,sizeof(s->inbuf));
2273                 res = read(s->fd, s->inbuf, 4);
2274                 if (res != 4) {
2275                         ast_log(LOG_WARNING, "Skinny Client sent less data than expected.\n");
2276                         return -1;
2277                 }
2278                 dlen = *(int *)s->inbuf;
2279                 res = read(s->fd, s->inbuf+4, dlen+4);
2280                 ast_mutex_unlock(&s->lock);
2281                 if (res != (dlen+4)) {
2282                         ast_log(LOG_WARNING, "Skinny Client sent less data than expected.\n");
2283                         return -1;
2284                 }
2285
2286         }
2287         return res;
2288 }
2289
2290
2291 static skinny_req *skinny_req_parse(struct skinnysession *s)
2292 {
2293         skinny_req *req;
2294
2295         req = malloc(SKINNY_MAX_PACKET);
2296         if (!req) {
2297                 ast_log(LOG_ERROR, "Unable to allocate skinny_request, this is bad\n");
2298                 return NULL;
2299         }
2300         memset(req, 0, sizeof(skinny_req));
2301         memcpy(req, s->inbuf, *(int*)(s->inbuf)+8); // +8
2302         if (req->e < 0) {
2303                 ast_log(LOG_ERROR, "Event Message is NULL from socket %d, This is bad\n", s->fd);
2304                 free(req);
2305                 return NULL;
2306         }
2307         return req;
2308 }
2309
2310 static void *skinny_session(void *data)
2311 {
2312         int res;
2313         skinny_req *req;
2314         struct skinnysession *s = data;
2315
2316         ast_verbose(VERBOSE_PREFIX_3 "Starting Skinny session from %s\n",  inet_ntoa(s->sin.sin_addr));
2317
2318         for (;;) {
2319                 res = 0;
2320                 res = get_input(s);
2321                 if (res < 0)
2322                         break;
2323                 req = skinny_req_parse(s);
2324                 if (!req) {
2325                         return NULL;
2326                 }
2327                 res = handle_message(req, s);
2328                 if (res < 0) {
2329                         destroy_session(s);
2330                         return NULL;
2331                 }
2332         }
2333         ast_log(LOG_NOTICE, "Skinny Session returned: %s\n", strerror(errno));
2334         destroy_session(s);
2335         return 0;
2336 }
2337
2338 static void *accept_thread(void *ignore)
2339 {
2340         int as;
2341         struct sockaddr_in sin;
2342         int sinlen;
2343         struct skinnysession *s;
2344         struct protoent *p;
2345         int arg = 1;
2346         pthread_attr_t attr;
2347
2348         pthread_attr_init(&attr);
2349         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
2350
2351         for (;;) {
2352                 sinlen = sizeof(sin);
2353                 as = accept(skinnysock, (struct sockaddr *)&sin, &sinlen);
2354                 if (as < 0) {
2355                         ast_log(LOG_NOTICE, "Accept returned -1: %s\n", strerror(errno));
2356                         continue;
2357                 }
2358                 p = getprotobyname("tcp");
2359                 if(p) {
2360                         if( setsockopt(as, p->p_proto, TCP_NODELAY, (char *)&arg, sizeof(arg) ) < 0 ) {
2361                                 ast_log(LOG_WARNING, "Failed to set Skinny tcp connection to TCP_NODELAY mode: %s\n", strerror(errno));
2362                         }
2363                 }
2364                 s = malloc(sizeof(struct skinnysession));
2365                 if (!s) {
2366                         ast_log(LOG_WARNING, "Failed to allocate Skinny session: %s\n", strerror(errno));
2367                         continue;
2368                 }
2369                 memset(s, 0, sizeof(struct skinnysession));
2370                 memcpy(&s->sin, &sin, sizeof(sin));
2371                 ast_mutex_init(&s->lock);
2372                 s->fd = as;
2373                 ast_mutex_lock(&sessionlock);
2374                 s->next = sessions;
2375                 sessions = s;
2376                 ast_mutex_unlock(&sessionlock);
2377
2378                 if (pthread_create(&tcp_thread, NULL, skinny_session, s))
2379                         destroy_session(s);
2380         }
2381
2382
2383         if (skinnydebug)
2384                 ast_verbose("killing accept thread\n");
2385
2386         close(as);
2387         return 0;
2388 }
2389
2390 static void *do_monitor(void *data)
2391 {
2392         int res;
2393
2394         /* This thread monitors all the interfaces which are not yet in use
2395            (and thus do not have a separate thread) indefinitely */
2396         /* From here on out, we die whenever asked */
2397         for(;;) {
2398                 pthread_testcancel();
2399                 /* Wait for sched or io */
2400                 res = ast_sched_wait(sched);
2401                 if ((res < 0) || (res > 1000))
2402                         res = 1000;
2403                 res = ast_io_wait(io, res);
2404                 ast_mutex_lock(&monlock);
2405                 if (res >= 0)
2406                         ast_sched_runq(sched);
2407                 ast_mutex_unlock(&monlock);
2408         }
2409         /* Never reached */
2410         return NULL;
2411
2412 }
2413
2414 static int restart_monitor(void)
2415 {
2416
2417         /* If we're supposed to be stopped -- stay stopped */
2418         if (monitor_thread == AST_PTHREADT_STOP)
2419                 return 0;
2420         if (ast_mutex_lock(&monlock)) {
2421                 ast_log(LOG_WARNING, "Unable to lock monitor\n");
2422                 return -1;
2423         }
2424         if (monitor_thread == pthread_self()) {
2425                 ast_mutex_unlock(&monlock);
2426                 ast_log(LOG_WARNING, "Cannot kill myself\n");
2427                 return -1;
2428         }
2429         if (monitor_thread != AST_PTHREADT_NULL) {
2430                 /* Wake up the thread */
2431                 pthread_kill(monitor_thread, SIGURG);
2432         } else {
2433                 /* Start a new monitor */
2434                 if (pthread_create(&monitor_thread, NULL, do_monitor, NULL) < 0) {
2435                         ast_mutex_unlock(&monlock);
2436                         ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
2437                         return -1;
2438                 }
2439         }
2440         ast_mutex_unlock(&monlock);
2441         return 0;
2442 }
2443
2444 static struct ast_channel *skinny_request(char *type, int format, void *data)
2445 {
2446         int oldformat;
2447         struct skinny_subchannel *sub;
2448         struct ast_channel *tmpc = NULL;
2449         char tmp[256];
2450         char *dest = data;
2451
2452         oldformat = format;
2453         format &= capability;
2454         if (!format) {
2455                 ast_log(LOG_NOTICE, "Asked to get a channel of unsupported format '%d'\n", format);
2456                 return NULL;
2457         }
2458
2459         strncpy(tmp, dest, sizeof(tmp) - 1);
2460         if (ast_strlen_zero(tmp)) {
2461                 ast_log(LOG_NOTICE, "Skinny channels require a device\n");
2462                 return NULL;
2463         }
2464
2465         sub = find_subchannel_by_name(tmp);
2466         if (!sub) {
2467                 ast_log(LOG_NOTICE, "No available lines on: %s\n", dest);
2468                 return NULL;
2469         }
2470
2471     if (option_verbose > 2) {
2472         ast_verbose(VERBOSE_PREFIX_3 "skinny_request(%s)\n", tmp);
2473         ast_verbose(VERBOSE_PREFIX_3 "Skinny cw: %d, dnd: %d, so: %d, sno: %d\n",
2474                     sub->parent->callwaiting, sub->parent->dnd, sub->owner ? 1 : 0, sub->next->owner ? 1: 0);
2475     }
2476
2477         tmpc = skinny_new(sub->owner ? sub->next : sub, AST_STATE_DOWN);
2478         if (!tmpc)
2479                 ast_log(LOG_WARNING, "Unable to make channel for '%s'\n", tmp);
2480         restart_monitor();
2481
2482         /* and finish */
2483         return tmpc;
2484 }
2485
2486 static int reload_config(void)
2487 {
2488         int on=1;
2489         struct ast_config *cfg;
2490         struct ast_variable *v;
2491         int format;
2492         char *cat;
2493         struct skinny_device *d;
2494         int oldport = ntohs(bindaddr.sin_port);
2495
2496         if (gethostname(ourhost, sizeof(ourhost))) {
2497                 ast_log(LOG_WARNING, "Unable to get hostname, Skinny disabled\n");
2498                 return 0;
2499         }
2500         cfg = ast_load(config);
2501
2502         /* We *must* have a config file otherwise stop immediately */
2503         if (!cfg) {
2504                 ast_log(LOG_NOTICE, "Unable to load config %s, Skinny disabled\n", config);
2505                 return 0;
2506         }
2507
2508         /* load the general section */
2509         memset(&bindaddr, 0, sizeof(bindaddr));
2510         v = ast_variable_browse(cfg, "general");
2511         while(v) {
2512                 /* Create the interface list */
2513                 if (!strcasecmp(v->name, "bindaddr")) {
2514                         if (!(hp = ast_gethostbyname(v->value, &ahp))) {
2515                                 ast_log(LOG_WARNING, "Invalid address: %s\n", v->value);
2516                         } else {
2517                                 memcpy(&bindaddr.sin_addr, hp->h_addr, sizeof(bindaddr.sin_addr));
2518                         }
2519                 } else if (!strcasecmp(v->name, "keepAlive")) {
2520                         keep_alive = atoi(v->value);
2521                 } else if (!strcasecmp(v->name, "dateFormat")) {
2522                         strncpy(date_format, v->value, sizeof(date_format) - 1);
2523                 } else if (!strcasecmp(v->name, "allow")) {
2524                         format = ast_getformatbyname(v->value);
2525                         if (format < 1)
2526                                 ast_log(LOG_WARNING, "Cannot allow unknown format '%s'\n", v->value);
2527                         else
2528                                 capability |= format;
2529                 } else if (!strcasecmp(v->name, "disallow")) {
2530                         format = ast_getformatbyname(v->value);
2531                         if (format < 1)
2532                                 ast_log(LOG_WARNING, "Cannot disallow unknown format '%s'\n", v->value);
2533                         else
2534                                 capability &= ~format;
2535                 } else if (!strcasecmp(v->name, "port")) {
2536                         if (sscanf(v->value, "%i", &ourport) == 1) {
2537                                 bindaddr.sin_port = htons(ourport);
2538                         } else {
2539                                 ast_log(LOG_WARNING, "Invalid port number '%s' at line %d of %s\n", v->value, v->lineno, config);
2540                         }
2541                 }
2542                 v = v->next;
2543         }
2544
2545         if (ntohl(bindaddr.sin_addr.s_addr)) {
2546                 memcpy(&__ourip, &bindaddr.sin_addr, sizeof(__ourip));
2547         } else {
2548                 hp = ast_gethostbyname(ourhost, &ahp);
2549                 if (!hp) {
2550                         ast_log(LOG_WARNING, "Unable to get our IP address, Skinny disabled\n");
2551                         return 0;
2552                 }
2553                 memcpy(&__ourip, hp->h_addr, sizeof(__ourip));
2554         }
2555         if (!ntohs(bindaddr.sin_port))
2556                 bindaddr.sin_port = ntohs(DEFAULT_SKINNY_PORT);
2557         bindaddr.sin_family = AF_INET;
2558
2559         /* load the device sections */
2560         cat = ast_category_browse(cfg, NULL);
2561         while(cat) {
2562                 if (strcasecmp(cat, "general")) {
2563                         d = build_device(cat, ast_variable_browse(cfg, cat));
2564                         if (d) {
2565                                 if (option_verbose > 2) {
2566                                         ast_verbose(VERBOSE_PREFIX_3 "Added device '%s'\n", d->name);
2567                 }
2568                                 ast_mutex_lock(&devicelock);
2569                                 d->next = devices;
2570                                 devices = d;
2571                                 ast_mutex_unlock(&devicelock);
2572                         }
2573                 }
2574                 cat = ast_category_browse(cfg, cat);
2575         }
2576         ast_mutex_lock(&netlock);
2577         if ((skinnysock > -1) && (ntohs(bindaddr.sin_port) != oldport)) {
2578                 close(skinnysock);
2579                 skinnysock = -1;
2580         }
2581         if (skinnysock < 0) {
2582                 skinnysock = socket(AF_INET, SOCK_STREAM, 0);
2583                 if(setsockopt(skinnysock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
2584                         ast_log(LOG_ERROR, "Set Socket Options failed: errno %d, %s", errno, strerror(errno));
2585                         return 0;
2586                 }
2587
2588                 if (skinnysock < 0) {
2589                         ast_log(LOG_WARNING, "Unable to create Skinny socket: %s\n", strerror(errno));
2590                 } else {
2591                         if (bind(skinnysock, (struct sockaddr *)&bindaddr, sizeof(bindaddr)) < 0) {
2592                                 ast_log(LOG_WARNING, "Failed to bind to %s:%d: %s\n",
2593                                                 inet_ntoa(bindaddr.sin_addr), ntohs(bindaddr.sin_port),
2594                                                         strerror(errno));
2595                                 close(skinnysock);
2596                                 skinnysock = -1;
2597                                 return 0;
2598                         }
2599
2600                         if (listen(skinnysock,DEFAULT_SKINNY_BACKLOG)) {
2601                                         ast_log(LOG_WARNING, "Failed to start listening to %s:%d: %s\n",
2602                                                 inet_ntoa(bindaddr.sin_addr), ntohs(bindaddr.sin_port),
2603                                                         strerror(errno));
2604                                         close(skinnysock);
2605                                         skinnysock = -1;
2606                                         return 0;
2607                         }
2608
2609                         if (option_verbose > 1)
2610                                 ast_verbose(VERBOSE_PREFIX_2 "Skinny listening on %s:%d\n",
2611                                         inet_ntoa(bindaddr.sin_addr), ntohs(bindaddr.sin_port));
2612
2613                         pthread_create(&accept_t,NULL, accept_thread, NULL);
2614
2615                 }
2616         }
2617         ast_mutex_unlock(&netlock);
2618
2619         /* and unload the configuration when were done */
2620         ast_destroy(cfg);
2621
2622         return 0;
2623 }
2624
2625 #if 0
2626 void delete_devices(void)
2627 {
2628         struct skinny_device *d, *dlast;
2629         struct skinny_line *l, *llast;
2630         struct skinny_subchannel *sub, *slast;
2631
2632         ast_mutex_lock(&devicelock);
2633
2634         /* Delete all devices */
2635         for (d=devices;d;) {
2636
2637                 /* Delete all lines for this device */
2638                 for (l=d->lines;l;) {
2639                         /* Delete all subchannels for this line */
2640                         for (sub=l->sub;sub;) {
2641                                 slast = sub;
2642                                 sub = sub->next;
2643                                 free(slast);
2644                         }
2645                         llast = l;
2646                         l = l->next;
2647                         free(llast);
2648                 }
2649                 dlast = d;
2650                 d = d->next;
2651                 free(dlast);
2652         }
2653         devices=NULL;
2654         ast_mutex_unlock(&devicelock);
2655 }
2656 #endif
2657
2658 int reload(void)
2659 {
2660 #if 0
2661 // XXX Causes Seg
2662
2663         delete_devices();
2664         reload_config();
2665         restart_monitor();
2666 #endif
2667         return 0;
2668 }
2669
2670
2671 int load_module()
2672 {
2673         int res = 0;
2674
2675         /* load and parse config */
2676         res = reload_config();
2677
2678         /* Announce our presence to Asterisk */
2679         if (!res) {
2680                 /* Make sure we can register our skinny channel type */
2681                 if (ast_channel_register(type, tdesc, capability, skinny_request)) {
2682                         ast_log(LOG_ERROR, "Unable to register channel class %s\n", type);
2683                         return -1;
2684                 }
2685         }
2686         skinny_rtp.type = type;
2687         ast_rtp_proto_register(&skinny_rtp);
2688         ast_cli_register(&cli_show_lines);
2689         ast_cli_register(&cli_debug);
2690         ast_cli_register(&cli_no_debug);
2691         sched = sched_context_create();
2692         if (!sched) {
2693                 ast_log(LOG_WARNING, "Unable to create schedule context\n");
2694         }
2695         io = io_context_create();
2696         if (!io) {
2697                 ast_log(LOG_WARNING, "Unable to create I/O context\n");
2698         }
2699         /* And start the monitor for the first time */
2700         restart_monitor();
2701         return res;
2702 }
2703
2704 int unload_module()
2705 {
2706 #if 0
2707         struct skinny_session *session, s;
2708         struct skinny_subchannel *sub;
2709         struct skinny_line *line = session;
2710
2711         /* close all IP connections */
2712         if (!ast_mutex_lock(&devicelock)) {
2713                 /* Terminate tcp listener thread */
2714
2715
2716         } else {
2717                 ast_log(LOG_WARNING, "Unable to lock the monitor\n");
2718                 return -1;
2719         }
2720         if (!ast_mutex_lock(&monlock)) {
2721                 if (monitor_thread && (monitor_thread != AST_PTHREADT_STOP)) {
2722                         pthread_cancel(monitor_thread);
2723                         pthread_kill(monitor_thread, SIGURG);
2724                         pthread_join(monitor_thread, NULL);
2725                 }
2726                 monitor_thread = AST_PTHREADT_STOP;
2727                 ast_mutex_unlock(&monlock);
2728         } else {
2729                 ast_log(LOG_WARNING, "Unable to lock the monitor\n");
2730                 return -1;
2731         }
2732         if (!ast_mutex_lock(&iflock)) {
2733                 /* Destroy all the interfaces and free their memory */
2734                 p = iflist;
2735                 while(p) {
2736                         pl = p;
2737                         p = p->next;
2738                         /* Free associated memory */
2739                         free(pl);
2740                 }
2741                 iflist = NULL;
2742                 ast_mutex_unlock(&iflock);
2743         } else {
2744                 ast_log(LOG_WARNING, "Unable to lock the monitor\n");
2745                 return -1;
2746         }
2747
2748         ast_rtp_proto_register(&skinny_rtp);
2749         ast_cli_register(&cli_show_lines);
2750         ast_cli_register(&cli_debug);
2751         ast_cli_register(&cli_no_debug);
2752
2753         return 0;
2754 #endif
2755         return -1;
2756 }
2757
2758 int usecount()
2759 {
2760         int res;
2761         ast_mutex_lock(&usecnt_lock);
2762         res = usecnt;
2763         ast_mutex_unlock(&usecnt_lock);
2764         return res;
2765 }
2766
2767 char *key()
2768 {
2769         return ASTERISK_GPL_KEY;
2770 }
2771
2772 char *description()
2773 {
2774         return desc;
2775 }