cb3b2937755d8c25250018e58272c9b4e6d32eb6
[lcr.git] / socket_server.c
1 /*****************************************************************************\
2 **                                                                           **
3 ** Linux Call Router                                                         **
4 **                                                                           **
5 **---------------------------------------------------------------------------**
6 ** Copyright: Andreas Eversberg                                              **
7 **                                                                           **
8 ** Socket link server                                                        **
9 **                                                                           **
10 \*****************************************************************************/
11
12 #include "main.h"
13 #include <sys/socket.h>
14 #include <sys/un.h>
15 #include <curses.h>
16 #ifdef PACKAGE_VERSION
17 #undef PACKAGE_VERSION
18 #endif
19 #include "config.h"
20
21
22 char socket_name[128];
23 int sock = -1;
24 struct sockaddr_un sock_address;
25
26 struct admin_list *admin_first = NULL;
27 static struct lcr_fd admin_fd;
28
29 int admin_handle(struct lcr_fd *fd, unsigned int what, void *instance, int index);
30
31 /*
32  * initialize admin socket 
33  */
34 int admin_init(void)
35 {
36         /* open and bind socket */
37         if ((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
38                 PERROR("Failed to create admin socket. (errno=%d)\n", errno);
39                 return(-1);
40         }
41         fhuse++;
42         memset(&sock_address, 0, sizeof(sock_address));
43         SPRINT(socket_name, SOCKET_NAME, options.lock);
44         sock_address.sun_family = AF_UNIX;
45         UCPY(sock_address.sun_path, socket_name);
46         unlink(socket_name);
47         if (bind(sock, (struct sockaddr *)(&sock_address), SUN_LEN(&sock_address)) < 0) {
48                 close(sock);
49                 unlink(socket_name);
50                 fhuse--;
51                 sock = -1;
52                 PERROR("Failed to bind admin socket to \"%s\". (errno=%d)\n", sock_address.sun_path, errno);
53                 return(-1);
54         }
55         if (listen(sock, 5) < 0) {
56                 close(sock);
57                 unlink(socket_name);
58                 fhuse--;
59                 sock = -1;
60                 PERROR("Failed to listen to socket \"%s\". (errno=%d)\n", sock_address.sun_path, errno);
61                 return(-1);
62         }
63         memset(&admin_fd, 0, sizeof(admin_fd));
64         admin_fd.fd = sock;
65         register_fd(&admin_fd, LCR_FD_READ | LCR_FD_EXCEPT, admin_handle, NULL, 0);
66         if (chmod(socket_name, options.socketrights) < 0) {
67                 PERROR("Failed to change socket rights to %d. (errno=%d)\n", options.socketrights, errno);
68         }
69         if (chown(socket_name, options.socketuser, options.socketgroup) < 0) {
70                 PERROR("Failed to change socket user/group to %d/%d. (errno=%d)\n", options.socketuser, options.socketgroup, errno);
71         }
72
73         return(0);
74 }
75
76
77 /*
78  * free connection
79  * also releases all remote joins
80  */
81 void free_connection(struct admin_list *admin)
82 {
83         struct admin_queue *response;
84         void *temp;
85 #ifdef WITH_MISDN
86         union parameter param;
87         class Join *join, *joinnext;
88         struct mISDNport *mISDNport;
89         int i, ii;
90         class Port *port, *portnext;
91         class Premote *remote;
92 #endif
93         struct admin_list **adminp;
94
95         /* free remote joins */
96         if (admin->remote_name[0]) {
97                 start_trace(-1,
98                         NULL,
99                         NULL,
100                         NULL,
101                         DIRECTION_NONE,
102                         0,
103                         0,
104                         "REMOTE APP release");
105                 add_trace("app", "name", "%s", admin->remote_name);
106                 end_trace();
107 #ifdef WITH_MISDN
108                 /* release all exported channels */
109                 mISDNport = mISDNport_first;
110                 while(mISDNport) {
111                         i = 0;
112                         ii = mISDNport->b_num;
113                         while(i < ii) {
114                                 if (mISDNport->b_remote_id[i] == admin->sock) {
115                                         mISDNport->b_state[i] = B_STATE_IDLE;
116                                         unsched_timer(&mISDNport->b_timer[i]);
117                                         mISDNport->b_remote_id[i] = 0;
118                                         mISDNport->b_remote_ref[i] = 0;
119                                 }
120                                 i++;
121                         }
122                         mISDNport = mISDNport->next;
123                 }
124 #endif
125 #ifdef WITH_MISDN
126                 /* release join */
127                 join = join_first;
128                 while(join) {
129                         joinnext = join->next;
130                         if (join->j_type==JOIN_TYPE_REMOTE) if (((class JoinRemote *)join)->j_remote_id == admin->sock) {
131                                 memset(&param, 0, sizeof(param));
132                                 param.disconnectinfo.cause = CAUSE_OUTOFORDER;
133                                 param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
134                                 ((class JoinRemote *)join)->message_remote(MESSAGE_RELEASE, &param);
135                                 /* join is now destroyed, so we go to next join */
136                         }
137                         join = joinnext;
138                 }
139                 /* release remote port */
140                 port = port_first;
141                 while(port) {
142                         portnext = port->next;
143                         if ((port->p_type & PORT_CLASS_MASK) == PORT_CLASS_REMOTE) {
144                                 remote = (class Premote *) port;
145                                 if (remote->p_m_r_remote_id == admin->sock) {
146                                         memset(&param, 0, sizeof(param));
147                                         param.disconnectinfo.cause = CAUSE_OUTOFORDER;
148                                         param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
149                                         remote->message_remote(MESSAGE_RELEASE, &param);
150                                         /* port is now destroyed, so we go to next join */
151                                 }
152                         }
153                         port = portnext;
154                 }
155 #endif
156         }
157
158         if (admin->sock >= 0) {
159                 unregister_fd(&admin->fd);
160                 close(admin->sock);
161                 fhuse--;
162         }
163         response = admin->response;
164         while (response) {
165                 temp = response->next;
166                 FREE(response, 0);
167                 memuse--;
168                 response = (struct admin_queue *)temp;
169         }
170
171         adminp = &admin_first;
172         while(*adminp) {
173                 if (*adminp == admin)
174                         break;
175                 adminp = &((*adminp)->next);
176         }
177         if (*adminp)
178                 *adminp = (*adminp)->next;
179
180         FREE(admin, 0);
181         memuse--;
182 }
183
184
185 /*
186  * cleanup admin socket 
187  */
188 void admin_cleanup(void)
189 {
190         struct admin_list *admin, *next;;
191
192         admin = admin_first;
193         while(admin) {
194                 next = admin->next;
195                 free_connection(admin);
196                 admin = next;
197         }
198
199         if (sock >= 0) {
200                 unregister_fd(&admin_fd);
201                 close(sock);
202                 fhuse--;
203         }
204
205         unlink(socket_name);
206 }
207
208
209 /*
210  * do interface reload
211  */
212 int admin_interface(struct admin_queue **responsep)
213 {
214         struct admin_queue      *response;      /* response pointer */
215         const char              *err_txt = "";
216         int                     err = 0;
217
218         if (read_interfaces()) {
219                 relink_interfaces();
220                 free_interfaces(interface_first);
221                 interface_first = interface_newlist;
222                 interface_newlist = NULL;
223         } else {
224                 err_txt = interface_error;
225                 err = -1;
226         }
227         /* create state response */
228         response = (struct admin_queue *)MALLOC(sizeof(struct admin_queue)+sizeof(admin_message));
229         memuse++;
230         response->num = 1;
231         /* message */
232         response->am[0].message = ADMIN_RESPONSE_CMD_INTERFACE;
233         /* error */
234         response->am[0].u.x.error = err;
235         /* message */
236         SCPY(response->am[0].u.x.message, err_txt);
237         /* attach to response chain */
238         *responsep = response;
239         responsep = &response->next;
240         return(0);
241 }
242
243
244 /*
245  * do route reload
246  */
247 int admin_route(struct admin_queue **responsep)
248 {
249         struct route_ruleset    *ruleset_new;
250         struct admin_queue      *response;      /* response pointer */
251         char                    err_txt[256] = "";
252         int                     err = 0;
253 #if 0
254         int                     n;
255 #endif
256         class EndpointAppPBX    *apppbx;
257
258 #if 0
259         n = 0;
260         apppbx = apppbx_first;
261         while(apppbx) {
262                 n++;
263                 apppbx = apppbx->next;
264         }
265         if (apppbx_first) {
266                 SPRINT(err_txt, "Cannot reload routing, because %d endpoints active\n", n);
267                 err = -1;
268                 goto response;
269         }
270 #endif
271         if (!(ruleset_new = ruleset_parse())) {
272                 SPRINT(err_txt, ruleset_error);
273                 err = -1;
274                 goto response;
275         }
276         ruleset_free(ruleset_first);
277         ruleset_first = ruleset_new;
278         ruleset_main = getrulesetbyname("main");
279         if (!ruleset_main) {
280                 SPRINT(err_txt, "Ruleset reloaded, but rule 'main' not found.\n");
281                 err = -1;
282         }
283         apppbx = apppbx_first;
284         while(apppbx) {
285                 if (apppbx->e_action) {
286                         switch(apppbx->e_action->index) {
287                                 case ACTION_INTERNAL:
288                                 apppbx->e_action = &action_internal;
289                                 break;
290                                 case ACTION_EXTERNAL:
291                                 apppbx->e_action = &action_external;
292                                 break;
293                                 case ACTION_REMOTE:
294                                 apppbx->e_action = &action_remote;
295                                 break;
296                                 case ACTION_VBOX_RECORD:
297                                 apppbx->e_action = &action_vbox;
298                                 break;
299                                 case ACTION_PARTYLINE:
300                                 apppbx->e_action = &action_partyline;
301                                 break;
302                                 default:
303                                 goto release;
304                         }
305                 } else if (apppbx->e_state != EPOINT_STATE_CONNECT) {
306                         release:
307                         unsched_timer(&apppbx->e_callback_timeout);
308                         apppbx->e_action = NULL;
309                         apppbx->release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0);
310                         start_trace(-1,
311                                 NULL,
312                                 numberrize_callerinfo(apppbx->e_callerinfo.id, apppbx->e_callerinfo.ntype, options.national, options.international),
313                                 apppbx->e_dialinginfo.id,
314                                 DIRECTION_NONE,
315                                 CATEGORY_EP,
316                                 apppbx->ea_endpoint->ep_serial,
317                                 "KICK (reload routing)");
318                         end_trace();
319                 }
320
321                 unsched_timer(&apppbx->e_action_timeout);
322                 apppbx->e_rule = NULL;
323                 apppbx->e_ruleset = NULL;
324
325                 apppbx = apppbx->next;
326         }
327
328         response:
329         /* create state response */
330         response = (struct admin_queue *)MALLOC(sizeof(struct admin_queue)+sizeof(admin_message));
331         memuse++;
332         response->num = 1;
333         /* message */
334         response->am[0].message = ADMIN_RESPONSE_CMD_ROUTE;
335         /* error */
336         response->am[0].u.x.error = err;
337         /* message */
338         SCPY(response->am[0].u.x.message, err_txt);
339         /* attach to response chain */
340         *responsep = response;
341         responsep = &response->next;
342         return(0);
343 }
344
345
346 /*
347  * do dialing
348  */
349 int admin_dial(struct admin_queue **responsep, char *message)
350 {
351         struct extension        ext;            /* temporary extension's settings */
352         struct admin_queue      *response;      /* response pointer */
353         char                    *p;             /* pointer to dialing digits */
354
355         /* create state response */
356         response = (struct admin_queue *)MALLOC(sizeof(struct admin_queue)+sizeof(admin_message));
357         memuse++;
358         response->num = 1;
359         /* message */
360         response->am[0].message = ADMIN_RESPONSE_CMD_DIAL;
361
362         /* process request */
363         if (!(p = strchr(message,':'))) {
364                 response->am[0].u.x.error = -EINVAL;
365                 SPRINT(response->am[0].u.x.message, "no seperator ':' in message to seperate number from extension");
366                 goto out;
367         }
368         *p++ = 0;
369
370         /* modify extension */
371         if (!read_extension(&ext, message)) {
372                 response->am[0].u.x.error = -EINVAL;
373                 SPRINT(response->am[0].u.x.message, "extension doesn't exist");
374                 goto out;
375         }
376         SCPY(ext.next, p);
377         write_extension(&ext, message);
378
379         out:
380         /* attach to response chain */
381         *responsep = response;
382         responsep = &response->next;
383         return(0);
384 }
385
386
387 /*
388  * do tracing
389  */
390 int admin_trace(struct admin_list *admin, struct admin_trace_req *trace)
391 {
392         memcpy(&admin->trace, trace, sizeof(struct admin_trace_req));
393         return(0);
394 }
395
396
397 /*
398  * do blocking
399  * 
400  * 0 = make port available
401  * 1 = make port administratively blocked
402  * 2 = unload port
403  * the result is returned:
404  * 0 = port is now available
405  * 1 = port is now blocked
406  * 2 = port cannot be loaded or has been unloaded
407  * -1 = port doesn't exist
408  */
409 int admin_block(struct admin_queue **responsep, int portnum, int block)
410 {
411         struct admin_queue      *response;      /* response pointer */
412         struct interface        *interface;
413         struct interface_port   *ifport;
414
415         /* create block response */
416         response = (struct admin_queue *)MALLOC(sizeof(struct admin_queue)+sizeof(admin_message));
417         memuse++;
418         response->num = 1;
419         /* message */
420         response->am[0].message = ADMIN_RESPONSE_CMD_BLOCK;
421         response->am[0].u.x.portnum = portnum;
422
423         /* search for port */
424         ifport = NULL;
425         interface = interface_first;
426         while(interface) {
427                 ifport = interface->ifport;
428                 while(ifport) {
429                         if (ifport->portnum == portnum)
430                                 break;
431                         ifport = ifport->next;
432                 }
433                 if (ifport)
434                         break;
435                 interface = interface->next;
436         }
437         /* not found, we return -1 */
438         if (!ifport) {
439                 response->am[0].u.x.block = -1;
440                 response->am[0].u.x.error = 1;
441                 SPRINT(response->am[0].u.x.message, "Port %d does not exist.", portnum);
442                 goto out;
443         }
444
445 #ifdef WITH_MISDN
446         /* no interface */
447         if (!ifport->mISDNport) {
448                 /* not loaded anyway */
449                 if (block >= 2) {
450                         response->am[0].u.x.block = 2;
451                         goto out;
452                 }
453
454                 /* try loading interface */
455                 ifport->block = block;
456                 load_mISDN_port(ifport);
457
458                 /* port cannot load */
459                 if (ifport->block >= 2) {
460                         response->am[0].u.x.block = 2;
461                         response->am[0].u.x.error = 1;
462                         SPRINT(response->am[0].u.x.message, "Port %d will not load.", portnum);
463                         goto out;
464                 }
465
466                 /* port loaded */
467                 response->am[0].u.x.block = ifport->block;
468                 goto out;
469         }
470
471         /* if we shall unload interface */
472         if (block >= 2) {
473                 mISDNport_close(ifport->mISDNport);
474                 ifport->mISDNport = 0;
475                 ifport->block = 2;
476                 goto out;
477         }
478 #endif
479         
480         /* port new blocking state */
481         ifport->block = response->am[0].u.x.block = block;
482
483         out:
484         /* attach to response chain */
485         *responsep = response;
486         responsep = &response->next;
487         return(0);
488 }
489
490
491 /*
492  * do release
493  */
494 int admin_release(struct admin_queue **responsep, char *message)
495 {
496         unsigned int            id;
497         struct admin_queue      *response;      /* response pointer */
498         class EndpointAppPBX    *apppbx;
499
500         /* create state response */
501         response = (struct admin_queue *)MALLOC(sizeof(struct admin_queue)+sizeof(admin_message));
502         memuse++;
503         response->num = 1;
504         /* message */
505         response->am[0].message = ADMIN_RESPONSE_CMD_RELEASE;
506
507         id = atoi(message);
508         apppbx = apppbx_first;
509         while(apppbx) {
510                 if (apppbx->ea_endpoint->ep_serial == id)
511                         break;
512                 apppbx = apppbx->next;
513         }
514         if (!apppbx) {
515                 response->am[0].u.x.error = -EINVAL;
516                 SPRINT(response->am[0].u.x.message, "Given endpoint %d doesn't exist.", id);
517                 goto out;
518         }
519
520         unsched_timer(&apppbx->e_callback_timeout);
521         apppbx->release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0);
522
523         out:
524         /* attach to response chain */
525         *responsep = response;
526         responsep = &response->next;
527         return(0);
528 }
529
530
531 /*
532  * do call
533  */
534 int admin_call(struct admin_list *admin, struct admin_message *msg)
535 {
536         class Endpoint          *epoint;
537         class EndpointAppPBX    *apppbx;
538
539         if (!(epoint = new Endpoint(0, 0)))
540                 FATAL("No memory for Endpoint instance\n");
541         if (!(epoint->ep_app = apppbx = new EndpointAppPBX(epoint, 1))) // outgoing
542                 FATAL("No memory for Endpoint Application instance\n");
543         apppbx->e_adminid = admin->sockserial;
544         admin->epointid = epoint->ep_serial;
545         SCPY(apppbx->e_callerinfo.id, nationalize_callerinfo(msg->u.call.callerid, &apppbx->e_callerinfo.ntype, options.national, options.international));
546         if (msg->u.call.present)
547                 apppbx->e_callerinfo.present = INFO_PRESENT_ALLOWED;
548         else
549                 apppbx->e_callerinfo.present = INFO_PRESENT_RESTRICTED;
550         apppbx->e_callerinfo.screen = INFO_SCREEN_NETWORK;
551
552
553         apppbx->e_capainfo.bearer_capa = msg->u.call.bc_capa;
554         apppbx->e_capainfo.bearer_mode = msg->u.call.bc_mode;
555         apppbx->e_capainfo.bearer_info1 = msg->u.call.bc_info1;
556         apppbx->e_capainfo.hlc = msg->u.call.hlc;
557         apppbx->e_capainfo.exthlc = msg->u.call.exthlc;
558         SCPY(apppbx->e_dialinginfo.id, msg->u.call.dialing);
559         SCPY(apppbx->e_dialinginfo.interfaces, msg->u.call.interface);
560         apppbx->e_dialinginfo.sending_complete = 1;
561
562         apppbx->new_state(PORT_STATE_OUT_SETUP);
563         apppbx->out_setup(0);
564         return(0);
565 }
566
567
568 /*
569  * this function is called for response whenever a call state changes.
570  */
571 void admin_call_response(int adminid, int message, const char *connected, int cause, int location, int notify_progress)
572 {
573         struct admin_list       *admin;
574         struct admin_queue      *response, **responsep; /* response pointer */
575
576         /* searching for admin id
577          * maybe there is no admin instance, because the calling port was not
578          * initiated by admin_call */
579         admin = admin_first;
580         while(admin) {
581                 if (adminid == admin->sockserial)
582                         break;
583                 admin = admin->next;
584         }
585         if (!admin)
586                 return;
587
588         /* seek to end of response list */
589         response = admin->response;
590         responsep = &admin->response;
591         while(response) {
592                 responsep = &response->next;
593                 response = response->next;
594         }
595
596         /* create state response */
597         response = (struct admin_queue *)MALLOC(sizeof(struct admin_queue)+sizeof(admin_message));
598         memuse++;
599         response->num = 1;
600         /* message */
601         response->am[0].message = message;
602
603         SCPY(response->am[0].u.call.callerid, connected);
604         response->am[0].u.call.cause = cause;
605         response->am[0].u.call.location = location;
606         response->am[0].u.call.notify_progress = notify_progress;
607
608         /* attach to response chain */
609         *responsep = response;
610         responsep = &response->next;
611         admin->fd.when |= LCR_FD_WRITE;
612 }
613
614
615 /*
616  * send data to the remote socket join instance
617  */
618 int admin_message_to_lcr(struct admin_msg *msg, struct admin_list *admin)
619 {
620 #ifdef WITH_MISDN
621         struct mISDNport                *mISDNport;
622         class Port                      *port;
623         class Premote                   *remote = NULL; /* make GCC happy */
624         class Join                      *join;
625         class JoinRemote                *joinremote = NULL; /* make GCC happy */
626 #endif
627         struct admin_list               *temp;
628
629         /* hello message */
630         if (msg->type == MESSAGE_HELLO) {
631                 if (admin->remote_name[0]) {
632                         PERROR("Remote application repeats hello message.\n");
633                         return(-1);
634                 }
635                 /* look for second application */
636                 temp = admin_first;
637                 while(temp) {
638                         if (!strcmp(temp->remote_name, msg->param.hello.application))
639                                 break;
640                         temp = temp->next;
641                 }
642                 if (temp) {
643                         PERROR("Remote application connects twice??? (ignoring)\n");
644                         return(-1);
645                 }
646                 /* set remote socket instance */
647                 SCPY(admin->remote_name, msg->param.hello.application);
648                 start_trace(-1,
649                         NULL,
650                         NULL,
651                         NULL,
652                         DIRECTION_NONE,
653                         0,
654                         0,
655                         "REMOTE APP registers");
656                 add_trace("app", "name", "%s", admin->remote_name);
657                 end_trace();
658                 return(0);
659         }
660
661         /* check we have no application name */
662         if (!admin->remote_name[0]) {
663                 PERROR("Remote application did not send us a hello message.\n");
664                 return(-1);
665         }
666
667 #ifdef WITH_MISDN
668         /* new join. the reply (NEWREF assignment) is sent from constructor */
669         if (msg->type == MESSAGE_NEWREF) {
670                 if (msg->param.newref.mode) {
671                         char name[32];
672                         /* find remote port */
673                         mISDNport = mISDNport_first;
674                         while(mISDNport) {
675                                 if (mISDNport->ifport->remote && !strcmp(mISDNport->ifport->remote_app, admin->remote_name))
676                                         break;
677                                 mISDNport = mISDNport->next;
678                         }
679                         if (!mISDNport) {
680                                 union parameter param;
681
682                                 /* create new join instance */
683                                 join = joinremote = new JoinRemote(0, admin->remote_name, admin->sock); // must have no serial, because no endpoint is connected
684                                 if (!join) {
685                                         FATAL("No memory for remote join instance\n");
686                                         return(-1);
687                                 }
688                                 memset(&param, 0, sizeof(union parameter));
689                                 param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
690                                 param.disconnectinfo.cause = CAUSE_RESSOURCEUNAVAIL;
691                                 admin_message_from_lcr(joinremote->j_remote_id, joinremote->j_remote_ref, MESSAGE_RELEASE, &param);
692                                 return 0;
693                         }
694                         /* creating port object, transparent until setup with hdlc */
695                         SPRINT(name, "%s-%s-in", mISDNport->ifport->interface->name, mISDNport->ifport->remote_app);
696                         if (!(remote = new Premote(PORT_TYPE_REMOTE_IN, mISDNport, name, NULL, 0, 0, B_MODE_TRANSPARENT, admin->sock)))
697
698                                 FATAL("Cannot create Port instance.\n");
699                 } else {
700                         /* create new join instance */
701                         join = new JoinRemote(0, admin->remote_name, admin->sock); // must have no serial, because no endpoint is connected
702                         if (!join) {
703                                 FATAL("No memory for remote join instance\n");
704                                 return(-1);
705                         }
706                 }
707                 return(0);
708         }
709 #endif
710
711 #ifdef WITH_MISDN
712         /* bchannel message
713          * no ref given for *_ack */
714         if (msg->type == MESSAGE_BCHANNEL)
715         if (msg->param.bchannel.type == BCHANNEL_ASSIGN_ACK
716          || msg->param.bchannel.type == BCHANNEL_REMOVE_ACK
717          || msg->param.bchannel.type == BCHANNEL_RELEASE) {
718                 /* no ref, but address */
719                 message_bchannel_from_remote(NULL, msg->param.bchannel.type, msg->param.bchannel.handle);
720                 return(0);
721         }
722 #endif
723         
724         /* check for ref */
725         if (!msg->ref) {
726                 PERROR("Remote application did not send us a valid ref with a message.\n");
727                 return(-1);
728         }
729
730 #ifdef WITH_MISDN
731         /* find join instance */
732         join = join_first;
733         while(join) {
734                 if (join->j_type == JOIN_TYPE_REMOTE) {
735                         joinremote = (class JoinRemote *)join;
736                         if (joinremote->j_remote_ref == msg->ref)
737                                 break;
738                 }
739                 join = join->next;
740         }
741         if (join) {
742                 if (admin->sock != joinremote->j_remote_id) {
743                         PERROR("Ref %d belongs to remote application %s, but not to sending application %s.\n", msg->ref, joinremote->j_remote_name, admin->remote_name);
744                         return(-1);
745                 }
746                 /* send message */
747                 joinremote->message_remote(msg->type, &msg->param);
748
749                 return(0);
750         }
751
752         /* find port instance */
753         port = port_first;
754         while(port) {
755                 if ((port->p_type & PORT_CLASS_mISDN_MASK) == PORT_CLASS_REMOTE) {
756                         remote = (class Premote *) port;
757                         if (remote->p_m_r_ref == msg->ref)
758                                 break;
759                 }
760                 port = port->next;
761         }
762         if (port) {
763                 if (admin->sock != remote->p_m_r_remote_id) {
764                         PERROR("Ref %d belongs to remote application %s, but not to sending application %s.\n", msg->ref, remote->p_m_r_remote_app, admin->remote_name);
765                         return(-1);
766                 }
767
768                 /* send message */
769                 remote->message_remote(msg->type, &msg->param);
770
771                 return(0);
772         }
773 #endif
774
775         PDEBUG(DEBUG_LOG, "No remote instance found with ref %d. (May have been already released.)\n", msg->ref);
776         return(0);
777
778 }
779
780
781 /*
782  * this function is called for every message to remote socket
783  */
784 int admin_message_from_lcr(int remote_id, unsigned int ref, int message_type, union parameter *param)
785 {
786         struct admin_list       *admin;
787         struct admin_queue      **responsep;    /* response pointer */
788
789         /* searching for admin id
790          * maybe there is no given remote application
791          */
792         admin = admin_first;
793         while(admin) {
794                 if (admin->remote_name[0] && admin->sock==remote_id)
795                         break;
796                 admin = admin->next;
797         }
798         /* no given remote application connected */
799         if (!admin)
800                 return(-1);
801
802         /* seek to end of response list */
803         responsep = &admin->response;
804         while(*responsep) {
805                 responsep = &(*responsep)->next;
806         }
807
808         /* create state response */
809         *responsep = (struct admin_queue *)MALLOC(sizeof(struct admin_queue)+sizeof(admin_message));
810         memuse++;
811         (*responsep)->num = 1;
812
813         /* message */
814         (*responsep)->am[0].message = ADMIN_MESSAGE;
815         (*responsep)->am[0].u.msg.type = message_type;
816         (*responsep)->am[0].u.msg.ref = ref;
817         memcpy(&(*responsep)->am[0].u.msg.param, param, sizeof(union parameter));
818         admin->fd.when |= LCR_FD_WRITE;
819         return(0);
820 }
821
822
823 /*
824  * do state debugging
825  */
826 int admin_state(struct admin_queue **responsep)
827 {
828         class Port              *port;
829         class EndpointAppPBX    *apppbx;
830         class Join              *join;
831 #ifdef WITH_MISDN
832         class Pdss1             *pdss1;
833         struct mISDNport        *mISDNport;
834         struct select_channel   *selchannel;
835         int                     anybusy;
836 #endif
837         struct interface        *interface;
838         struct interface_port   *ifport;
839         int                     i;
840         int                     num;
841         struct admin_queue      *response;
842         struct admin_list       *admin;
843         struct tm               *now_tm;
844         time_t                  now;
845
846         /* create state response */
847         response = (struct admin_queue *)MALLOC(sizeof(struct admin_queue)+sizeof(admin_message));
848         memuse++;
849         response->num = 1;
850         /* message */
851         response->am[0].message = ADMIN_RESPONSE_STATE;
852         /* version */
853         SCPY(response->am[0].u.s.version_string, VERSION_STRING);
854         /* time */
855         time(&now);
856         now_tm = localtime(&now);
857         memcpy(&response->am[0].u.s.tm, now_tm, sizeof(struct tm));
858         /* log file */
859         SCPY(response->am[0].u.s.logfile, options.log);
860         /* interface count */
861         i = 0;
862         interface = interface_first;
863         while(interface) {
864                 ifport = interface->ifport;
865                 if (!ifport)
866                         i++;
867                 while(ifport) {
868                         i++;
869                         ifport = ifport->next;
870                 }
871                 interface = interface->next;
872         }
873         response->am[0].u.s.interfaces = i;
874         /* remote connection count */
875         i = 0;
876         admin = admin_first;
877         while(admin) {
878                 if (admin->remote_name[0])
879                         i++;
880                 admin = admin->next;
881         }
882         response->am[0].u.s.remotes = i;
883         /* join count */
884         join = join_first;
885         i = 0;
886         while(join) {
887                 i++;
888                 join = join->next;
889         }
890         response->am[0].u.s.joins = i;
891         /* apppbx count */
892         apppbx = apppbx_first;
893         i = 0;
894         while(apppbx) {
895                 i++;
896                 apppbx = apppbx->next;
897         }
898         response->am[0].u.s.epoints = i;
899         /* port count */
900         i = 0;
901         port = port_first;
902         while(port) {
903                 i++;
904                 port = port->next;
905         }
906         response->am[0].u.s.ports = i;
907         /* attach to response chain */
908         *responsep = response;
909         responsep = &response->next;
910
911         /* create response for all instances */
912         num = (response->am[0].u.s.interfaces)
913             + (response->am[0].u.s.remotes)
914             + (response->am[0].u.s.joins)
915             + (response->am[0].u.s.epoints)
916             + (response->am[0].u.s.ports);
917         if (num == 0)
918                 return(0);
919         response = (struct admin_queue *)MALLOC(sizeof(admin_queue)+(num*sizeof(admin_message)));
920         memuse++;
921         response->num = num;
922         *responsep = response;
923         responsep = &response->next;
924         interface = interface_first;
925         num = 0;
926         while(interface) {
927                 ifport = interface->ifport;
928                 if (!ifport) {
929                         /* message */
930                         response->am[num].message = ADMIN_RESPONSE_S_INTERFACE;
931                         /* interface */
932                         SCPY(response->am[num].u.i.interface_name, interface->name);
933                         /* portnum */
934                         response->am[num].u.i.portnum = -100; /* indicate: no ifport */
935                         /* iftype */
936                         response->am[num].u.i.extension = interface->extension;
937                         /* block */
938                         num++;
939                 }
940                 while(ifport) {
941                         /* message */
942                         response->am[num].message = ADMIN_RESPONSE_S_INTERFACE;
943                         /* interface */
944                         SCPY(response->am[num].u.i.interface_name, interface->name);
945                         /* portnum */
946                         response->am[num].u.i.portnum = ifport->portnum;
947                         /* portname */
948                         SCPY(response->am[num].u.i.portname, ifport->portname);
949                         /* iftype */
950                         response->am[num].u.i.extension = interface->extension;
951                         /* block */
952                         response->am[num].u.i.block = ifport->block;
953 #ifdef WITH_MISDN
954                         if (ifport->mISDNport) {
955                                 mISDNport = ifport->mISDNport;
956
957                                 /* ptp */
958                                 response->am[num].u.i.ptp = mISDNport->ptp;
959                                 /* l1hold */
960                                 response->am[num].u.i.l1hold = mISDNport->l1hold;
961                                 /* l2hold */
962                                 response->am[num].u.i.l2hold = mISDNport->l2hold;
963                                 /* ntmode */
964                                 response->am[num].u.i.ntmode = mISDNport->ntmode;
965                                 /* pri */
966                                 response->am[num].u.i.pri = mISDNport->pri;
967                                 /* use */
968                                 response->am[num].u.i.use = mISDNport->use;
969                                 /* l1link */
970                                 response->am[num].u.i.l1link = mISDNport->l1link;
971                                 /* l2link */
972                                 response->am[num].u.i.l2link = mISDNport->l2link;
973                                 memcpy(response->am[num].u.i.l2mask, mISDNport->l2mask, 16);
974                                 /* los */
975                                 response->am[num].u.i.los = mISDNport->los;
976                                 /* ais */
977                                 response->am[num].u.i.ais = mISDNport->ais;
978                                 /* rdi */
979                                 response->am[num].u.i.rdi = mISDNport->rdi;
980                                 /* slip */
981                                 response->am[num].u.i.slip_tx = mISDNport->slip_tx;
982                                 response->am[num].u.i.slip_rx = mISDNport->slip_rx;
983                                 /* channels */
984                                 response->am[num].u.i.channels = mISDNport->b_num;
985                                 /* channel selection */
986                                 selchannel = ifport->out_channel;
987                                 if (ifport->channel_force)
988                                         SCAT(response->am[num].u.i.out_channel, "force");
989                                 while (selchannel) {
990                                         if (response->am[num].u.i.out_channel[0])
991                                                 SCAT(response->am[num].u.i.out_channel, ",");
992                                         switch (selchannel->channel) {
993                                         case CHANNEL_NO:
994                                                 SCAT(response->am[num].u.i.out_channel, "no");
995                                                 break;
996                                         case CHANNEL_ANY:
997                                                 SCAT(response->am[num].u.i.out_channel, "any");
998                                                 break;
999                                         case CHANNEL_FREE:
1000                                                 SCAT(response->am[num].u.i.out_channel, "free");
1001                                                 break;
1002                                         default:
1003                                                 SPRINT(strchr(response->am[num].u.i.out_channel, '\0'), "%d", selchannel->channel);
1004                                         }
1005                                         selchannel = selchannel->next;
1006                                 }
1007                                 selchannel = ifport->in_channel;
1008                                 while (selchannel) {
1009                                         switch (selchannel->channel) {
1010                                         case CHANNEL_FREE:
1011                                                 SCAT(response->am[num].u.i.in_channel, "free");
1012                                                 break;
1013                                         default:
1014                                                 SPRINT(strchr(response->am[num].u.i.in_channel, '\0'), "%d", selchannel->channel);
1015                                         }
1016                                         selchannel = selchannel->next;
1017                                 }
1018                                 /* channel state */
1019                                 i = 0;
1020                                 anybusy = 0;
1021                                 while(i < mISDNport->b_num) {
1022                                         response->am[num].u.i.busy[i] = mISDNport->b_state[i];
1023                                         if (mISDNport->b_port[i])
1024                                                 response->am[num].u.i.port[i] = mISDNport->b_port[i]->p_serial;
1025                                         response->am[num].u.i.mode[i] = mISDNport->b_mode[i];
1026                                         i++;
1027                                 }
1028                         }
1029 #endif
1030                         num++;
1031
1032                         ifport = ifport->next;
1033                 }
1034                 interface = interface->next;
1035         }
1036
1037         /* create response for all remotes */
1038         admin = admin_first;
1039         while(admin) {
1040                 if (admin->remote_name[0]) {
1041                         /* message */
1042                         response->am[num].message = ADMIN_RESPONSE_S_REMOTE;
1043                         /* name */
1044                         SCPY(response->am[num].u.r.name, admin->remote_name);
1045                         /* */
1046                         num++;
1047                 }
1048                 admin = admin->next;
1049         }
1050
1051         /* create response for all joins */
1052         join = join_first;
1053         while(join) {
1054                 /* message */
1055                 response->am[num].message = ADMIN_RESPONSE_S_JOIN;
1056                 /* serial */
1057                 response->am[num].u.j.serial = join->j_serial;
1058                 /* partyline */
1059                 if (join->j_type == JOIN_TYPE_PBX)
1060                         response->am[num].u.j.partyline = ((class JoinPBX *)join)->j_partyline;
1061                 /* remote application */
1062                 if (join->j_type == JOIN_TYPE_REMOTE)
1063                         SCPY(response->am[num].u.j.remote, ((class JoinRemote *)join)->j_remote_name);
1064                 /* */
1065                 join = join->next;
1066                 num++;
1067         }
1068
1069         /* create response for all endpoint */
1070         apppbx = apppbx_first;
1071         while(apppbx) {
1072                 /* message */
1073                 response->am[num].message = ADMIN_RESPONSE_S_EPOINT;
1074                 /* serial */
1075                 response->am[num].u.e.serial = apppbx->ea_endpoint->ep_serial;
1076                 /* join */
1077                 response->am[num].u.e.join = apppbx->ea_endpoint->ep_join_id;
1078                 /* rx notification */
1079                 response->am[num].u.e.rx_state = apppbx->e_rx_state;
1080                 /* tx notification */
1081                 response->am[num].u.e.tx_state = apppbx->e_tx_state;
1082                 /* state */
1083                 switch(apppbx->e_state) {
1084                         case EPOINT_STATE_IN_SETUP:
1085                         response->am[num].u.e.state = ADMIN_STATE_IN_SETUP;
1086                         break;
1087                         case EPOINT_STATE_OUT_SETUP:
1088                         response->am[num].u.e.state = ADMIN_STATE_OUT_SETUP;
1089                         break;
1090                         case EPOINT_STATE_IN_OVERLAP:
1091                         response->am[num].u.e.state = ADMIN_STATE_IN_OVERLAP;
1092                         break;
1093                         case EPOINT_STATE_OUT_OVERLAP:
1094                         response->am[num].u.e.state = ADMIN_STATE_OUT_OVERLAP;
1095                         break;
1096                         case EPOINT_STATE_IN_PROCEEDING:
1097                         response->am[num].u.e.state = ADMIN_STATE_IN_PROCEEDING;
1098                         break;
1099                         case EPOINT_STATE_OUT_PROCEEDING:
1100                         response->am[num].u.e.state = ADMIN_STATE_OUT_PROCEEDING;
1101                         break;
1102                         case EPOINT_STATE_IN_ALERTING:
1103                         response->am[num].u.e.state = ADMIN_STATE_IN_ALERTING;
1104                         break;
1105                         case EPOINT_STATE_OUT_ALERTING:
1106                         response->am[num].u.e.state = ADMIN_STATE_OUT_ALERTING;
1107                         break;
1108                         case EPOINT_STATE_CONNECT:
1109                         response->am[num].u.e.state = ADMIN_STATE_CONNECT;
1110                         break;
1111                         case EPOINT_STATE_IN_DISCONNECT:
1112                         response->am[num].u.e.state = ADMIN_STATE_IN_DISCONNECT;
1113                         break;
1114                         case EPOINT_STATE_OUT_DISCONNECT:
1115                         response->am[num].u.e.state = ADMIN_STATE_OUT_DISCONNECT;
1116                         break;
1117                         default:
1118                         response->am[num].u.e.state = ADMIN_STATE_IDLE;
1119                 }
1120                 /* terminal */
1121                 SCPY(response->am[num].u.e.terminal, apppbx->e_ext.number);
1122                 /* callerid */
1123                 SCPY(response->am[num].u.e.callerid, apppbx->e_callerinfo.id);
1124                 /* dialing */
1125                 SCPY(response->am[num].u.e.dialing, apppbx->e_dialinginfo.id);
1126                 /* action string */
1127                 if (apppbx->e_action)
1128                         SCPY(response->am[num].u.e.action, action_defs[apppbx->e_action->index].name);
1129 //              if (apppbx->e_action)
1130 //              printf("action=%s\n",action_defs[apppbx->e_action->index].name);
1131                 /* park */
1132                 response->am[num].u.e.park = apppbx->ea_endpoint->ep_park;
1133                 if (apppbx->ea_endpoint->ep_park && apppbx->ea_endpoint->ep_park_len && apppbx->ea_endpoint->ep_park_len<=(int)sizeof(response->am[num].u.e.park_callid))
1134                         memcpy(response->am[num].u.e.park_callid, apppbx->ea_endpoint->ep_park_callid, apppbx->ea_endpoint->ep_park_len);
1135                 response->am[num].u.e.park_len = apppbx->ea_endpoint->ep_park_len;
1136 #ifdef WITH_CRYPT
1137                 /* crypt */
1138                 if (apppbx->e_crypt == CRYPT_ON)
1139                         response->am[num].u.e.crypt = 1;
1140 #endif
1141                 /* */
1142                 apppbx = apppbx->next;
1143                 num++;
1144         }
1145
1146         /* create response for all ports */
1147         port = port_first;
1148         while(port) {
1149                 /* message */
1150                 response->am[num].message = ADMIN_RESPONSE_S_PORT;
1151                 /* serial */
1152                 response->am[num].u.p.serial = port->p_serial;
1153                 /* name */
1154                 SCPY(response->am[num].u.p.name, port->p_name);
1155                 /* epoint */
1156                 response->am[num].u.p.epoint = ACTIVE_EPOINT(port->p_epointlist);
1157                 /* state */
1158                 switch(port->p_state) {
1159                         case PORT_STATE_IN_SETUP:
1160                         response->am[num].u.p.state = ADMIN_STATE_IN_SETUP;
1161                         break;
1162                         case PORT_STATE_OUT_SETUP:
1163                         response->am[num].u.p.state = ADMIN_STATE_OUT_SETUP;
1164                         break;
1165                         case PORT_STATE_IN_OVERLAP:
1166                         response->am[num].u.p.state = ADMIN_STATE_IN_OVERLAP;
1167                         break;
1168                         case PORT_STATE_OUT_OVERLAP:
1169                         response->am[num].u.p.state = ADMIN_STATE_OUT_OVERLAP;
1170                         break;
1171                         case PORT_STATE_IN_PROCEEDING:
1172                         response->am[num].u.p.state = ADMIN_STATE_IN_PROCEEDING;
1173                         break;
1174                         case PORT_STATE_OUT_PROCEEDING:
1175                         response->am[num].u.p.state = ADMIN_STATE_OUT_PROCEEDING;
1176                         break;
1177                         case PORT_STATE_IN_ALERTING:
1178                         response->am[num].u.p.state = ADMIN_STATE_IN_ALERTING;
1179                         break;
1180                         case PORT_STATE_OUT_ALERTING:
1181                         response->am[num].u.p.state = ADMIN_STATE_OUT_ALERTING;
1182                         break;
1183                         case PORT_STATE_CONNECT:
1184                         response->am[num].u.p.state = ADMIN_STATE_CONNECT;
1185                         break;
1186                         case PORT_STATE_IN_DISCONNECT:
1187                         response->am[num].u.p.state = ADMIN_STATE_IN_DISCONNECT;
1188                         break;
1189                         case PORT_STATE_OUT_DISCONNECT:
1190                         response->am[num].u.p.state = ADMIN_STATE_OUT_DISCONNECT;
1191                         break;
1192                         case PORT_STATE_RELEASE:
1193                         response->am[num].u.p.state = ADMIN_STATE_RELEASE;
1194                         break;
1195                         default:
1196                         response->am[num].u.p.state = ADMIN_STATE_IDLE;
1197                 }
1198 #ifdef WITH_MISDN
1199                 /* isdn */
1200                 if ((port->p_type & PORT_CLASS_mISDN_MASK) == PORT_CLASS_DSS1) {
1201                         response->am[num].u.p.isdn = 1;
1202                         pdss1 = (class Pdss1 *)port;
1203                         response->am[num].u.p.isdn_chan = pdss1->p_m_b_channel;
1204                         response->am[num].u.p.isdn_hold = pdss1->p_m_hold;
1205                         response->am[num].u.p.isdn_ces = pdss1->p_m_d_ces;
1206                 }
1207 #endif
1208                 /* */
1209                 port = port->next;
1210                 num++;
1211         }
1212         return(0);
1213 }
1214
1215 int sockserial = 1; // must start with 1, because 0 is used if no serial is set
1216 /*
1217  * handle admin socket (non blocking)
1218  */
1219 int admin_handle_con(struct lcr_fd *fd, unsigned int what, void *instance, int index);
1220
1221 int admin_handle(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1222 {
1223         int                     new_sock;
1224         socklen_t               sock_len = sizeof(sock_address);
1225         struct admin_list       *admin;
1226
1227         /* check for new incoming connections */
1228         if ((new_sock = accept(sock, (struct sockaddr *)&sock_address, &sock_len)) >= 0) {
1229                 /* insert new socket */
1230                 admin = (struct admin_list *)MALLOC(sizeof(struct admin_list));
1231                 memuse++;
1232                 fhuse++;
1233                 admin->sockserial = sockserial++;
1234                 admin->next = admin_first;
1235                 admin_first = admin;
1236                 admin->sock = new_sock;
1237                 admin->fd.fd = new_sock;
1238                 register_fd(&admin->fd, LCR_FD_READ | LCR_FD_EXCEPT, admin_handle_con, admin, 0);
1239         } else {
1240                 if (errno != EWOULDBLOCK) {
1241                         PERROR("Failed to accept connection from socket \"%s\". (errno=%d) Closing socket.\n", sock_address.sun_path, errno);
1242                         admin_cleanup();
1243                         return 0;
1244                 }
1245         }
1246
1247         return 0;
1248 }
1249
1250 int admin_handle_con(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1251 {
1252         struct admin_list *admin = (struct admin_list *)instance;
1253         void                    *temp;
1254         struct admin_message    msg;
1255         int                     len;
1256         struct Endpoint         *epoint;
1257
1258         if ((what & LCR_FD_READ)) {
1259                 /* read command */
1260                 len = read(admin->sock, &msg, sizeof(msg));
1261                 if (len < 0) {
1262                         brokenpipe:
1263                         PDEBUG(DEBUG_LOG, "Broken pipe on socket %d. (errno=%d).\n", admin->sock, errno);
1264                         end:
1265                         /*release endpoint if exists */
1266                         if (admin->epointid) {
1267                                 epoint = find_epoint_id(admin->epointid);
1268                                 if (epoint && epoint->ep_app_type == EAPP_TYPE_PBX) {
1269                                         ((class EndpointAppPBX *)epoint->ep_app)->
1270                                                 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0);
1271                                 }
1272                         }
1273
1274                         free_connection(admin);
1275                         return 0;
1276                 }
1277                 if (len == 0)
1278                         goto end;
1279                 if (len != sizeof(msg)) {
1280                         PERROR("Short/long read on socket %d. (len=%d != size=%d).\n", admin->sock, len, sizeof(msg));
1281                         goto end;
1282                 }
1283                 /* process socket command */
1284                 if (admin->response && msg.message != ADMIN_MESSAGE) {
1285                         PERROR("Data from socket %d while sending response.\n", admin->sock);
1286                         goto end;
1287                 }
1288                 switch (msg.message) {
1289                         case ADMIN_REQUEST_CMD_INTERFACE:
1290                         if (admin_interface(&admin->response) < 0) {
1291                                 PERROR("Failed to create dial response for socket %d.\n", admin->sock);
1292                                 goto response_error;
1293                         }
1294                         admin->fd.when |= LCR_FD_WRITE;
1295                         break;
1296
1297                         case ADMIN_REQUEST_CMD_ROUTE:
1298                         if (admin_route(&admin->response) < 0) {
1299                                 PERROR("Failed to create dial response for socket %d.\n", admin->sock);
1300                                 goto response_error;
1301                         }
1302                         admin->fd.when |= LCR_FD_WRITE;
1303                         break;
1304
1305                         case ADMIN_REQUEST_CMD_DIAL:
1306                         if (admin_dial(&admin->response, msg.u.x.message) < 0) {
1307                                 PERROR("Failed to create dial response for socket %d.\n", admin->sock);
1308                                 goto response_error;
1309                         }
1310                         admin->fd.when |= LCR_FD_WRITE;
1311                         break;
1312
1313                         case ADMIN_REQUEST_CMD_RELEASE:
1314                         if (admin_release(&admin->response, msg.u.x.message) < 0) {
1315                                 PERROR("Failed to create release response for socket %d.\n", admin->sock);
1316                                 goto response_error;
1317                         }
1318                         admin->fd.when |= LCR_FD_WRITE;
1319                         break;
1320
1321                         case ADMIN_REQUEST_STATE:
1322                         if (admin_state(&admin->response) < 0) {
1323                                 PERROR("Failed to create state response for socket %d.\n", admin->sock);
1324                                 goto response_error;
1325                         }
1326                         admin->fd.when |= LCR_FD_WRITE;
1327                         break;
1328
1329                         case ADMIN_TRACE_REQUEST:
1330                         if (admin_trace(admin, &msg.u.trace_req) < 0) {
1331                                 PERROR("Failed to create trace response for socket %d.\n", admin->sock);
1332                                 goto response_error;
1333                         }
1334                         admin->fd.when |= LCR_FD_WRITE;
1335                         break;
1336
1337                         case ADMIN_REQUEST_CMD_BLOCK:
1338                         if (admin_block(&admin->response, msg.u.x.portnum, msg.u.x.block) < 0) {
1339                                 PERROR("Failed to create block response for socket %d.\n", admin->sock);
1340                                 goto response_error;
1341                         }
1342                         admin->fd.when |= LCR_FD_WRITE;
1343                         break;
1344
1345                         case ADMIN_MESSAGE:
1346                         if (admin_message_to_lcr(&msg.u.msg, admin) < 0) {
1347                                 PERROR("Failed to deliver message for socket %d.\n", admin->sock);
1348                                 goto response_error;
1349                         }
1350                         break;
1351
1352                         case ADMIN_CALL_SETUP:
1353                         if (admin_call(admin, &msg) < 0) {
1354                                 PERROR("Failed to create call for socket %d.\n", admin->sock);
1355                                 response_error:
1356                                 goto end;
1357                         }
1358                         break;
1359
1360                         default:
1361                         PERROR("Invalid message %d from socket %d.\n", msg.message, admin->sock);
1362                         goto end;
1363                 }
1364         }
1365
1366         if ((what & LCR_FD_WRITE)) {
1367                 /* write queue */
1368                 if (admin->response) {
1369                         len = write(admin->sock, ((unsigned char *)(admin->response->am))+admin->response->offset, sizeof(struct admin_message)*(admin->response->num)-admin->response->offset);
1370                         if (len < 0) {
1371                                 goto brokenpipe;
1372                         }
1373                         if (len == 0)
1374                                 goto end;
1375                         if (len < (int)(sizeof(struct admin_message)*(admin->response->num) - admin->response->offset)) {
1376                                 admin->response->offset+=len;
1377                                 return 0;
1378                         } else {
1379                                 temp = admin->response;
1380                                 admin->response = admin->response->next;
1381                                 FREE(temp, 0);
1382                                 memuse--;
1383                         }
1384                 } else
1385                         admin->fd.when &= ~LCR_FD_WRITE;
1386         }
1387
1388         return 0;
1389 }
1390
1391 void message_bchannel_to_remote(unsigned int remote_id, unsigned int ref, int type, unsigned int handle, int tx_gain, int rx_gain, char *pipeline, unsigned char *crypt, int crypt_len, int crypt_type, int isloopback)
1392 {
1393         union parameter param;
1394
1395         memset(&param, 0, sizeof(union parameter));
1396         param.bchannel.isloopback = isloopback;
1397         param.bchannel.type = type;
1398         param.bchannel.handle = handle;
1399         param.bchannel.tx_gain = tx_gain;
1400         param.bchannel.rx_gain = rx_gain;
1401         if (pipeline)
1402                 SCPY(param.bchannel.pipeline, pipeline);
1403         if (crypt_len)
1404                 memcpy(param.bchannel.crypt, crypt, crypt_len);
1405         param.bchannel.crypt_type = crypt_type;
1406         if (admin_message_from_lcr(remote_id, ref, MESSAGE_BCHANNEL, &param)<0) {
1407                 PERROR("No socket with remote id %d found, this happens, if the socket is closed before all bchannels are imported.\n", remote_id);
1408                 return;         
1409         }
1410 }
1411