src/libcharon/plugins/smp/smp.c

   1 /*
   2  * Copyright (C) 2007 Martin Willi
   3  * Hochschule fuer Technik Rapperswil
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2 of the License, or (at your
   8  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14  */
  15
  16 #include <stdlib.h>
  17
  18 #include "smp.h"
  19
  20 #include <sys/types.h>
  21 #include <sys/stat.h>
  22 #include <sys/socket.h>
  23 #include <sys/un.h>
  24 #include <unistd.h>
  25 #include <errno.h>
  26 #include <signal.h>
  27 #include <libxml/xmlreader.h>
  28 #include <libxml/xmlwriter.h>
  29
  30 #include <library.h>
  31 #include <daemon.h>
  32 #include <threading/thread.h>
  33 #include <processing/jobs/callback_job.h>
  34
  35
  36 typedef struct private_smp_t private_smp_t;
  37
  38 /**
  39  * Private data of an smp_t object.
  40  */
  41 struct private_smp_t {
  42
  43         /**
  44          * Public part of smp_t object.
  45          */
  46         smp_t public;
  47
  48         /**
  49          * XML unix socket fd
  50          */
  51         int socket;
  52
  53         /**
  54          * job accepting stroke messages
  55          */
  56         callback_job_t *job;
  57 };
  58
  59 ENUM(ike_sa_state_lower_names, IKE_CREATED, IKE_DELETING,
  60         "created",
  61         "connecting",
  62         "established",
  63         "rekeying",
  64         "deleting",
  65 );
  66
  67 /**
  68  * write a bool into element
  69  */
  70 static void write_bool(xmlTextWriterPtr writer, char *element, bool val)
  71 {
  72         xmlTextWriterWriteElement(writer, element, val ? "true" : "false");
  73 }
  74
  75 /**
  76  * write a identification_t into element
  77  */
  78 static void write_id(xmlTextWriterPtr writer, char *element, identification_t *id)
  79 {
  80         xmlTextWriterStartElement(writer, element);
  81         switch (id->get_type(id))
  82         {
  83                 {
  84                         char *type = "";
  85                         while (TRUE)
  86                         {
  87                                 case ID_ANY:
  88                                         type = "any";
  89                                         break;
  90                                 case ID_IPV4_ADDR:
  91                                         type = "ipv4";
  92                                         break;
  93                                 case ID_IPV6_ADDR:
  94                                         type = "ipv6";
  95                                         break;
  96                                 case ID_FQDN:
  97                                         type = "fqdn";
  98                                         break;
  99                                 case ID_RFC822_ADDR:
 100                                         type = "email";
 101                                         break;
 102                                 case ID_DER_ASN1_DN:
 103                                         type = "asn1dn";
 104                                         break;
 105                                 case ID_DER_ASN1_GN:
 106                                         type = "asn1gn";
 107                                         break;
 108                         }
 109                         xmlTextWriterWriteAttribute(writer, "type", type);
 110                         xmlTextWriterWriteFormatString(writer, "%Y", id);
 111                         break;
 112                 }
 113                 default:
 114                         /* TODO: base64 keyid */
 115                         xmlTextWriterWriteAttribute(writer, "type", "keyid");
 116                         break;
 117         }
 118         xmlTextWriterEndElement(writer);
 119 }
 120
 121 /**
 122  * write a host_t address into an element
 123  */
 124 static void write_address(xmlTextWriterPtr writer, char *element, host_t *host)
 125 {
 126         xmlTextWriterStartElement(writer, element);
 127         xmlTextWriterWriteAttribute(writer, "type",
 128                                                 host->get_family(host) == AF_INET ? "ipv4" : "ipv6");
 129         if (host->is_anyaddr(host))
 130         {       /* do not use %any for XML */
 131                 xmlTextWriterWriteFormatString(writer, "%s",
 132                                                 host->get_family(host) == AF_INET ? "0.0.0.0" : "::");
 133         }
 134         else
 135         {
 136                 xmlTextWriterWriteFormatString(writer, "%H", host);
 137         }
 138         xmlTextWriterEndElement(writer);
 139 }
 140
 141 /**
 142  * write networks element
 143  */
 144 static void write_networks(xmlTextWriterPtr writer, char *element,
 145                                                    linked_list_t *list)
 146 {
 147         enumerator_t *enumerator;
 148         traffic_selector_t *ts;
 149
 150         xmlTextWriterStartElement(writer, element);
 151         enumerator = list->create_enumerator(list);
 152         while (enumerator->enumerate(enumerator, (void**)&ts))
 153         {
 154                 xmlTextWriterStartElement(writer, "network");
 155                 xmlTextWriterWriteAttribute(writer, "type",
 156                                                 ts->get_type(ts) == TS_IPV4_ADDR_RANGE ? "ipv4" : "ipv6");
 157                 xmlTextWriterWriteFormatString(writer, "%R", ts);
 158                 xmlTextWriterEndElement(writer);
 159         }
 160         enumerator->destroy(enumerator);
 161         xmlTextWriterEndElement(writer);
 162 }
 163
 164 /**
 165  * write a childEnd
 166  */
 167 static void write_childend(xmlTextWriterPtr writer, child_sa_t *child, bool local)
 168 {
 169         linked_list_t *list;
 170
 171         xmlTextWriterWriteFormatElement(writer, "spi", "%lx",
 172                                                                         htonl(child->get_spi(child, local)));
 173         list = child->get_traffic_selectors(child, local);
 174         write_networks(writer, "networks", list);
 175 }
 176
 177 /**
 178  * write a child_sa_t
 179  */
 180 static void write_child(xmlTextWriterPtr writer, child_sa_t *child)
 181 {
 182         child_cfg_t *config;
 183
 184         config = child->get_config(child);
 185
 186         xmlTextWriterStartElement(writer, "childsa");
 187         xmlTextWriterWriteFormatElement(writer, "reqid", "%d",
 188                                                                         child->get_reqid(child));
 189         xmlTextWriterWriteFormatElement(writer, "childconfig", "%s",
 190                                                                         config->get_name(config));
 191         xmlTextWriterStartElement(writer, "local");
 192         write_childend(writer, child, TRUE);
 193         xmlTextWriterEndElement(writer);
 194         xmlTextWriterStartElement(writer, "remote");
 195         write_childend(writer, child, FALSE);
 196         xmlTextWriterEndElement(writer);
 197         xmlTextWriterEndElement(writer);
 198 }
 199
 200 /**
 201  * process a ikesalist query request message
 202  */
 203 static void request_query_ikesa(xmlTextReaderPtr reader, xmlTextWriterPtr writer)
 204 {
 205         enumerator_t *enumerator;
 206         ike_sa_t *ike_sa;
 207
 208         /* <ikesalist> */
 209         xmlTextWriterStartElement(writer, "ikesalist");
 210
 211         enumerator = charon->controller->create_ike_sa_enumerator(charon->controller);
 212         while (enumerator->enumerate(enumerator, &ike_sa))
 213         {
 214                 ike_sa_id_t *id;
 215                 host_t *local, *remote;
 216                 iterator_t *children;
 217                 child_sa_t *child_sa;
 218
 219                 id = ike_sa->get_id(ike_sa);
 220
 221                 xmlTextWriterStartElement(writer, "ikesa");
 222                 xmlTextWriterWriteFormatElement(writer, "id", "%d",
 223                                                         ike_sa->get_unique_id(ike_sa));
 224                 xmlTextWriterWriteFormatElement(writer, "status", "%N",
 225                                                         ike_sa_state_lower_names, ike_sa->get_state(ike_sa));
 226                 xmlTextWriterWriteElement(writer, "role",
 227                                                         id->is_initiator(id) ? "initiator" : "responder");
 228                 xmlTextWriterWriteElement(writer, "peerconfig", ike_sa->get_name(ike_sa));
 229
 230                 /* <local> */
 231                 local = ike_sa->get_my_host(ike_sa);
 232                 xmlTextWriterStartElement(writer, "local");
 233                 xmlTextWriterWriteFormatElement(writer, "spi", "%.16llx",
 234                                                         id->is_initiator(id) ? id->get_initiator_spi(id)
 235                                                                                                  : id->get_responder_spi(id));
 236                 write_id(writer, "identification", ike_sa->get_my_id(ike_sa));
 237                 write_address(writer, "address", local);
 238                 xmlTextWriterWriteFormatElement(writer, "port", "%d",
 239                                                         local->get_port(local));
 240                 if (ike_sa->supports_extension(ike_sa, EXT_NATT))
 241                 {
 242                         write_bool(writer, "nat", ike_sa->has_condition(ike_sa, COND_NAT_HERE));
 243                 }
 244                 xmlTextWriterEndElement(writer);
 245                 /* </local> */
 246
 247                 /* <remote> */
 248                 remote = ike_sa->get_other_host(ike_sa);
 249                 xmlTextWriterStartElement(writer, "remote");
 250                 xmlTextWriterWriteFormatElement(writer, "spi", "%.16llx",
 251                                                         id->is_initiator(id) ? id->get_responder_spi(id)
 252                                                                                                  : id->get_initiator_spi(id));
 253                 write_id(writer, "identification", ike_sa->get_other_id(ike_sa));
 254                 write_address(writer, "address", remote);
 255                 xmlTextWriterWriteFormatElement(writer, "port", "%d",
 256                                                         remote->get_port(remote));
 257                 if (ike_sa->supports_extension(ike_sa, EXT_NATT))
 258                 {
 259                         write_bool(writer, "nat", ike_sa->has_condition(ike_sa, COND_NAT_THERE));
 260                 }
 261                 xmlTextWriterEndElement(writer);
 262                 /* </remote> */
 263
 264                 /* <childsalist> */
 265                 xmlTextWriterStartElement(writer, "childsalist");
 266                 children = ike_sa->create_child_sa_iterator(ike_sa);
 267                 while (children->iterate(children, (void**)&child_sa))
 268                 {
 269                         write_child(writer, child_sa);
 270                 }
 271                 children->destroy(children);
 272                 /* </childsalist> */
 273                 xmlTextWriterEndElement(writer);
 274
 275                 /* </ikesa> */
 276                 xmlTextWriterEndElement(writer);
 277         }
 278         enumerator->destroy(enumerator);
 279
 280         /* </ikesalist> */
 281         xmlTextWriterEndElement(writer);
 282 }
 283
 284 /**
 285  * process a configlist query request message
 286  */
 287 static void request_query_config(xmlTextReaderPtr reader, xmlTextWriterPtr writer)
 288 {
 289         enumerator_t *enumerator;
 290         peer_cfg_t *peer_cfg;
 291
 292         /* <configlist> */
 293         xmlTextWriterStartElement(writer, "configlist");
 294
 295         enumerator = charon->backends->create_peer_cfg_enumerator(charon->backends,
 296                                                                                                                 NULL, NULL, NULL, NULL);
 297         while (enumerator->enumerate(enumerator, &peer_cfg))
 298         {
 299                 enumerator_t *children;
 300                 child_cfg_t *child_cfg;
 301                 ike_cfg_t *ike_cfg;
 302                 linked_list_t *list;
 303
 304                 if (peer_cfg->get_ike_version(peer_cfg) != 2)
 305                 {       /* only IKEv2 connections yet */
 306                         continue;
 307                 }
 308
 309                 /* <peerconfig> */
 310                 xmlTextWriterStartElement(writer, "peerconfig");
 311                 xmlTextWriterWriteElement(writer, "name", peer_cfg->get_name(peer_cfg));
 312
 313                 /* TODO: write auth_cfgs */
 314
 315                 /* <ikeconfig> */
 316                 ike_cfg = peer_cfg->get_ike_cfg(peer_cfg);
 317                 xmlTextWriterStartElement(writer, "ikeconfig");
 318                 xmlTextWriterWriteElement(writer, "local", ike_cfg->get_my_addr(ike_cfg));
 319                 xmlTextWriterWriteElement(writer, "remote", ike_cfg->get_other_addr(ike_cfg));
 320                 xmlTextWriterEndElement(writer);
 321                 /* </ikeconfig> */
 322
 323                 /* <childconfiglist> */
 324                 xmlTextWriterStartElement(writer, "childconfiglist");
 325                 children = peer_cfg->create_child_cfg_enumerator(peer_cfg);
 326                 while (children->enumerate(children, &child_cfg))
 327                 {
 328                         /* <childconfig> */
 329                         xmlTextWriterStartElement(writer, "childconfig");
 330                         xmlTextWriterWriteElement(writer, "name",
 331                                                                           child_cfg->get_name(child_cfg));
 332                         list = child_cfg->get_traffic_selectors(child_cfg, TRUE, NULL, NULL);
 333                         write_networks(writer, "local", list);
 334                         list->destroy_offset(list, offsetof(traffic_selector_t, destroy));
 335                         list = child_cfg->get_traffic_selectors(child_cfg, FALSE, NULL, NULL);
 336                         write_networks(writer, "remote", list);
 337                         list->destroy_offset(list, offsetof(traffic_selector_t, destroy));
 338                         xmlTextWriterEndElement(writer);
 339                         /* </childconfig> */
 340                 }
 341                 children->destroy(children);
 342                 /* </childconfiglist> */
 343                 xmlTextWriterEndElement(writer);
 344                 /* </peerconfig> */
 345                 xmlTextWriterEndElement(writer);
 346         }
 347         enumerator->destroy(enumerator);
 348         /* </configlist> */
 349         xmlTextWriterEndElement(writer);
 350 }
 351
 352 /**
 353  * callback which logs to a XML writer
 354  */
 355 static bool xml_callback(xmlTextWriterPtr writer, debug_t group, level_t level,
 356                                                  ike_sa_t* ike_sa, char* format, va_list args)
 357 {
 358         if (level <= 1)
 359         {
 360                 /* <item> */
 361                 xmlTextWriterStartElement(writer, "item");
 362                 xmlTextWriterWriteFormatAttribute(writer, "level", "%d", level);
 363                 xmlTextWriterWriteFormatAttribute(writer, "source", "%N", debug_names, group);
 364                 xmlTextWriterWriteFormatAttribute(writer, "thread", "%u", thread_current_id());
 365                 xmlTextWriterWriteVFormatString(writer, format, args);
 366                 xmlTextWriterEndElement(writer);
 367                 /* </item> */
 368         }
 369         return TRUE;
 370 }
 371
 372 /**
 373  * process a *terminate control request message
 374  */
 375 static void request_control_terminate(xmlTextReaderPtr reader,
 376                                                                           xmlTextWriterPtr writer, bool ike)
 377 {
 378         if (xmlTextReaderRead(reader) &&
 379                 xmlTextReaderNodeType(reader) == XML_READER_TYPE_TEXT)
 380         {
 381                 const char *str;
 382                 u_int32_t id;
 383                 status_t status;
 384
 385                 str = xmlTextReaderConstValue(reader);
 386                 if (str == NULL)
 387                 {
 388                         DBG1(DBG_CFG, "error parsing XML id string");
 389                         return;
 390                 }
 391                 id = atoi(str);
 392                 if (!id)
 393                 {
 394                         enumerator_t *enumerator;
 395                         ike_sa_t *ike_sa;
 396
 397                         enumerator = charon->controller->create_ike_sa_enumerator(charon->controller);
 398                         while (enumerator->enumerate(enumerator, &ike_sa))
 399                         {
 400                                 if (streq(str, ike_sa->get_name(ike_sa)))
 401                                 {
 402                                         ike = TRUE;
 403                                         id = ike_sa->get_unique_id(ike_sa);
 404                                         break;
 405                                 }
 406                         }
 407                         enumerator->destroy(enumerator);
 408                 }
 409                 if (!id)
 410                 {
 411                         DBG1(DBG_CFG, "error parsing XML id string");
 412                         return;
 413                 }
 414
 415                 DBG1(DBG_CFG, "terminating %s_SA %d", ike ? "IKE" : "CHILD", id);
 416
 417                 /* <log> */
 418                 xmlTextWriterStartElement(writer, "log");
 419                 if (ike)
 420                 {
 421                         status = charon->controller->terminate_ike(
 422                                         charon->controller,     id,
 423                                         (controller_cb_t)xml_callback, writer);
 424                 }
 425                 else
 426                 {
 427                         status = charon->controller->terminate_child(
 428                                         charon->controller,     id,
 429                                         (controller_cb_t)xml_callback, writer);
 430                 }
 431                 /* </log> */
 432                 xmlTextWriterEndElement(writer);
 433                 xmlTextWriterWriteFormatElement(writer, "status", "%d", status);
 434         }
 435 }
 436
 437 /**
 438  * process a *initiate control request message
 439  */
 440 static void request_control_initiate(xmlTextReaderPtr reader,
 441                                                                           xmlTextWriterPtr writer, bool ike)
 442 {
 443         if (xmlTextReaderRead(reader) &&
 444                 xmlTextReaderNodeType(reader) == XML_READER_TYPE_TEXT)
 445         {
 446                 const char *str;
 447                 status_t status = FAILED;
 448                 peer_cfg_t *peer;
 449                 child_cfg_t *child = NULL;
 450                 enumerator_t *enumerator;
 451
 452                 str = xmlTextReaderConstValue(reader);
 453                 if (str == NULL)
 454                 {
 455                         DBG1(DBG_CFG, "error parsing XML config name string");
 456                         return;
 457                 }
 458                 DBG1(DBG_CFG, "initiating %s_SA %s", ike ? "IKE" : "CHILD", str);
 459
 460                 /* <log> */
 461                 xmlTextWriterStartElement(writer, "log");
 462                 peer = charon->backends->get_peer_cfg_by_name(charon->backends, (char*)str);
 463                 if (peer)
 464                 {
 465                         enumerator = peer->create_child_cfg_enumerator(peer);
 466                         if (ike)
 467                         {
 468                                 if (!enumerator->enumerate(enumerator, &child))
 469                                 {
 470                                         child = NULL;
 471                                 }
 472                                 child->get_ref(child);
 473                         }
 474                         else
 475                         {
 476                                 while (enumerator->enumerate(enumerator, &child))
 477                                 {
 478                                         if (streq(child->get_name(child), str))
 479                                         {
 480                                                 child->get_ref(child);
 481                                                 break;
 482                                         }
 483                                         child = NULL;
 484                                 }
 485                         }
 486                         enumerator->destroy(enumerator);
 487                         if (child)
 488                         {
 489                                 status = charon->controller->initiate(charon->controller,
 490                                                         peer, child, (controller_cb_t)xml_callback,
 491                                                         writer);
 492                         }
 493                         else
 494                         {
 495                                 peer->destroy(peer);
 496                         }
 497                 }
 498                 /* </log> */
 499                 xmlTextWriterEndElement(writer);
 500                 xmlTextWriterWriteFormatElement(writer, "status", "%d", status);
 501         }
 502 }
 503
 504 /**
 505  * process a query request
 506  */
 507 static void request_query(xmlTextReaderPtr reader, xmlTextWriterPtr writer)
 508 {
 509         /* <query> */
 510         xmlTextWriterStartElement(writer, "query");
 511         while (xmlTextReaderRead(reader))
 512         {
 513                 if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT)
 514                 {
 515                         if (streq(xmlTextReaderConstName(reader), "ikesalist"))
 516                         {
 517                                 request_query_ikesa(reader, writer);
 518                                 break;
 519                         }
 520                         if (streq(xmlTextReaderConstName(reader), "configlist"))
 521                         {
 522                                 request_query_config(reader, writer);
 523                                 break;
 524                         }
 525                 }
 526         }
 527         /* </query> */
 528         xmlTextWriterEndElement(writer);
 529 }
 530
 531 /**
 532  * process a control request
 533  */
 534 static void request_control(xmlTextReaderPtr reader, xmlTextWriterPtr writer)
 535 {
 536         /* <control> */
 537         xmlTextWriterStartElement(writer, "control");
 538         while (xmlTextReaderRead(reader))
 539         {
 540                 if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT)
 541                 {
 542                         if (streq(xmlTextReaderConstName(reader), "ikesaterminate"))
 543                         {
 544                                 request_control_terminate(reader, writer, TRUE);
 545                                 break;
 546                         }
 547                         if (streq(xmlTextReaderConstName(reader), "childsaterminate"))
 548                         {
 549                                 request_control_terminate(reader, writer, FALSE);
 550                                 break;
 551                         }
 552                         if (streq(xmlTextReaderConstName(reader), "ikesainitiate"))
 553                         {
 554                                 request_control_initiate(reader, writer, TRUE);
 555                                 break;
 556                         }
 557                         if (streq(xmlTextReaderConstName(reader), "childsainitiate"))
 558                         {
 559                                 request_control_initiate(reader, writer, FALSE);
 560                                 break;
 561                         }
 562                 }
 563         }
 564         /* </control> */
 565         xmlTextWriterEndElement(writer);
 566 }
 567
 568 /**
 569  * process a request message
 570  */
 571 static void request(xmlTextReaderPtr reader, char *id, int fd)
 572 {
 573         xmlTextWriterPtr writer;
 574
 575         writer = xmlNewTextWriter(xmlOutputBufferCreateFd(fd, NULL));
 576         if (writer == NULL)
 577         {
 578                 DBG1(DBG_CFG, "opening SMP XML writer failed");
 579                 return;
 580         }
 581
 582         xmlTextWriterStartDocument(writer, NULL, NULL, NULL);
 583         /* <message xmlns="http://www.strongswan.org/smp/1.0"
 584                 id="id" type="response"> */
 585         xmlTextWriterStartElement(writer, "message");
 586         xmlTextWriterWriteAttribute(writer, "xmlns",
 587                                                                 "http://www.strongswan.org/smp/1.0");
 588         xmlTextWriterWriteAttribute(writer, "id", id);
 589         xmlTextWriterWriteAttribute(writer, "type", "response");
 590
 591         while (xmlTextReaderRead(reader))
 592         {
 593                 if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT)
 594                 {
 595                         if (streq(xmlTextReaderConstName(reader), "query"))
 596                         {
 597                                 request_query(reader, writer);
 598                                 break;
 599                         }
 600                         if (streq(xmlTextReaderConstName(reader), "control"))
 601                         {
 602                                 request_control(reader, writer);
 603                                 break;
 604                         }
 605                 }
 606         }
 607         /*   </message> and close document */
 608         xmlTextWriterEndDocument(writer);
 609         xmlFreeTextWriter(writer);
 610 }
 611
 612 /**
 613  * cleanup helper function for open file descriptors
 614  */
 615 static void closefdp(int *fd)
 616 {
 617         close(*fd);
 618 }
 619
 620 /**
 621  * read from a opened connection and process it
 622  */
 623 static job_requeue_t process(int *fdp)
 624 {
 625         int fd = *fdp;
 626         bool oldstate;
 627         char buffer[4096];
 628         size_t len;
 629         xmlTextReaderPtr reader;
 630         char *id = NULL, *type = NULL;
 631
 632         thread_cleanup_push((thread_cleanup_t)closefdp, (void*)&fd);
 633         oldstate = thread_cancelability(TRUE);
 634         len = read(fd, buffer, sizeof(buffer));
 635         thread_cancelability(oldstate);
 636         thread_cleanup_pop(FALSE);
 637         if (len <= 0)
 638         {
 639                 close(fd);
 640                 DBG2(DBG_CFG, "SMP XML connection closed");
 641                 return JOB_REQUEUE_NONE;
 642         }
 643         DBG3(DBG_CFG, "got XML request: %b", buffer, len);
 644
 645         reader = xmlReaderForMemory(buffer, len, NULL, NULL, 0);
 646         if (reader == NULL)
 647         {
 648                 DBG1(DBG_CFG, "opening SMP XML reader failed");
 649                 return JOB_REQUEUE_FAIR;;
 650         }
 651
 652         /* read message type and id */
 653         while (xmlTextReaderRead(reader))
 654         {
 655                 if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT &&
 656                         streq(xmlTextReaderConstName(reader), "message"))
 657                 {
 658                         id = xmlTextReaderGetAttribute(reader, "id");
 659                         type = xmlTextReaderGetAttribute(reader, "type");
 660                         break;
 661                 }
 662         }
 663
 664         /* process message */
 665         if (id && type)
 666         {
 667                 if (streq(type, "request"))
 668                 {
 669                         request(reader, id, fd);
 670                 }
 671                 else
 672                 {
 673                         /* response(reader, id) */
 674                 }
 675         }
 676         xmlFreeTextReader(reader);
 677         return JOB_REQUEUE_FAIR;;
 678 }
 679
 680 /**
 681  * accept from XML socket and create jobs to process connections
 682  */
 683 static job_requeue_t dispatch(private_smp_t *this)
 684 {
 685         struct sockaddr_un strokeaddr;
 686         int fd, *fdp, strokeaddrlen = sizeof(strokeaddr);
 687         callback_job_t *job;
 688         bool oldstate;
 689
 690         /* wait for connections, but allow thread to terminate */
 691         oldstate = thread_cancelability(TRUE);
 692         fd = accept(this->socket, (struct sockaddr *)&strokeaddr, &strokeaddrlen);
 693         thread_cancelability(oldstate);
 694
 695         if (fd < 0)
 696         {
 697                 DBG1(DBG_CFG, "accepting SMP XML socket failed: %s", strerror(errno));
 698                 sleep(1);
 699                 return JOB_REQUEUE_FAIR;;
 700         }
 701
 702         fdp = malloc_thing(int);
 703         *fdp = fd;
 704         job = callback_job_create((callback_job_cb_t)process, fdp, free, this->job);
 705         lib->processor->queue_job(lib->processor, (job_t*)job);
 706
 707         return JOB_REQUEUE_DIRECT;
 708 }
 709
 710 METHOD(plugin_t, get_name, char*,
 711         private_smp_t *this)
 712 {
 713         return "smp";
 714 }
 715
 716 METHOD(plugin_t, destroy, void,
 717         private_smp_t *this)
 718 {
 719         this->job->cancel(this->job);
 720         close(this->socket);
 721         free(this);
 722 }
 723
 724 /*
 725  * Described in header file
 726  */
 727 plugin_t *smp_plugin_create()
 728 {
 729         struct sockaddr_un unix_addr = { AF_UNIX, IPSEC_PIDDIR "/charon.xml"};
 730         private_smp_t *this;
 731         mode_t old;
 732
 733         INIT(this,
 734                 .public = {
 735                         .plugin = {
 736                                 .get_name = _get_name,
 737                                 .destroy = _destroy,
 738                         },
 739                 },
 740         );
 741
 742         /* set up unix socket */
 743         this->socket = socket(AF_UNIX, SOCK_STREAM, 0);
 744         if (this->socket == -1)
 745         {
 746                 DBG1(DBG_CFG, "could not create XML socket");
 747                 free(this);
 748                 return NULL;
 749         }
 750
 751         unlink(unix_addr.sun_path);
 752         old = umask(~(S_IRWXU | S_IRWXG));
 753         if (bind(this->socket, (struct sockaddr *)&unix_addr, sizeof(unix_addr)) < 0)
 754         {
 755                 DBG1(DBG_CFG, "could not bind XML socket: %s", strerror(errno));
 756                 close(this->socket);
 757                 free(this);
 758                 return NULL;
 759         }
 760         umask(old);
 761         if (chown(unix_addr.sun_path, charon->uid, charon->gid) != 0)
 762         {
 763                 DBG1(DBG_CFG, "changing XML socket permissions failed: %s", strerror(errno));
 764         }
 765
 766         if (listen(this->socket, 5) < 0)
 767         {
 768                 DBG1(DBG_CFG, "could not listen on XML socket: %s", strerror(errno));
 769                 close(this->socket);
 770                 free(this);
 771                 return NULL;
 772         }
 773
 774         this->job = callback_job_create((callback_job_cb_t)dispatch, this, NULL, NULL);
 775         lib->processor->queue_job(lib->processor, (job_t*)this->job);
 776
 777         return &this->public.plugin;
 778 }
 779