router.c

linux下简单对象应用协议的开发库

            flag = 0;
            if (*++arg)
              service_endpoint = arg;
            else if (i < argc && argv[++i])
              service_endpoint = argv[i];
            else
            { fprintf(stderr, "router: -e and -g require <endpoint>\n");
              exit(1);
            }
            break;
          case 'a':
            flag = 0;
            if (*++arg)
              service_action = arg;
            else if (i < argc && argv[++i])
              service_action = argv[i];
            else
            { fprintf(stderr, "router: -a requires <action>\n");
              exit(1);
            }
            break;
          case 'r':
            flag = 0;
            if (*++arg)
              routing_file = arg;
            else if (i < argc && argv[++i])
              routing_file = argv[i];
            else
            { fprintf(stderr, "router: -r requires <routingfile>\n");
              exit(1);
            }
            break;
          case 't':
            flag = 0;
            if (*++arg)
              server_timeout = atol(arg);
            else if (i < argc && argv[++i])
              server_timeout = atol(argv[i]);
            else
            { fprintf(stderr, "router: -t requires <timeout>\n");
              exit(1);
            }
            break;
	  case 'c':
	    connect_flag = 1;
	    break;
          default:
            fprintf(stderr, "router: unknown option -%c\n", *arg);
	}
    }
    else
      input_file = arg;
  }
}

void*
process_request(void *soap)
{ struct soap *client, server;
  soap_wchar c;
  pthread_detach(pthread_self());
  client = (struct soap*)soap;
  soap_init(&server);
  soap_begin(client);
  c = soap_get0(client);
  if (c == 'G' || c == 'P') /* simple check to see if HTTP GET/POST header is present */
  { if (copy_header(client, &server, NULL, NULL))
      client->error = server.error;
  }
  else
  { buffer_body(client);
    if (create_header(&server, method, service_endpoint, service_action, client->length))
      client->error = server.error;
  }
  if (!client->error)
  { copy_body(client, &server);
    soap_begin(&server);
    copy_header(&server, client, NULL, NULL);
    copy_body(&server, client);
  }
  else
    soap_send_fault(client);
  soap_closesock(client);
  soap_closesock(&server);
  soap_end(client);
  soap_end(&server);
  soap_done(client);
  soap_done(&server);
  free(soap);
  return NULL;
}

const char*
lookup(struct t__RoutingTable *route, const char *key, const char *userid, const char *passwd)
{ static struct t__RoutingTable routing_table = {0, NULL}; /* file-based routing table cache */
  if (!key)
    return NULL; /* can't do lookup on nil key */
  if (!route->__ptr)
  { route->__ptr = routing; /* first stage: use internal routing table */
    route->__size = 999999999;
  }
  else if (route->__size)
  { route->__ptr++;
    route->__size--;
  }
  for (;;)
  { if (route->__ptr)
    { while (route->__size && route->__ptr->key)
      { if (!soap_tag_cmp(key, route->__ptr->key))
	  if (!route->__ptr->userid
	   || !route->__ptr->passwd
	   || !soap_tag_cmp(userid, route->__ptr->userid)
	   || !soap_tag_cmp(passwd, route->__ptr->passwd))
          return route->__ptr->endpoint;
        route->__ptr++;
        route->__size--;
      }
    }
    if (route->__size) /* second stage: use file-based routing table */
    { if (routing_table.__ptr)
        *route = routing_table; /* table is already cached in memory */
      else if (routing_file) /* else read table from file */
      { struct soap soap;
        soap_init(&soap);
        soap.recvfd = open(routing_file, O_RDONLY);
        if (soap.recvfd < 0) /* no routing file: silently stop */
	{ soap_done(&soap);
	  break;
	}
        if (!soap_begin_recv(&soap))
	  if (!soap_get_t__RoutingTable(&soap, &routing_table, "router", NULL))
	  { close(soap.recvfd);
	    soap_done(&soap);
	    break;
	  }
	soap_end_recv(&soap);
	close(soap.recvfd);
	soap_done(&soap);
	*route = routing_table;
      }
    }
    else
      break;
  }
  return NULL;
}

int
make_connect(struct soap *server, const char *endpoint)
{ char host[SOAP_TAGLEN];
  int port;
  strcpy(host, server->host);
  port = server->port;
  soap_set_endpoint(server, endpoint);	/* get host, path, and port */
  server->connect_timeout = server_timeout;
  server->recv_timeout = server_timeout;
  server->send_timeout = server_timeout;
  /* server->connect_flags = SO_NOSIGPIPE; */	/* prevents UNIX SIGPIPE */
  /* server->socket_flags = MSG_NOSIGNAL; */	/* prevents UNIX SIGPIPE */
  if (*server->host)
  { if (server->socket < 0 || strcmp(server->host, host) || server->port != port)
    { soap_closesock(server);
      server->socket = server->fopen(server, endpoint, server->host, server->port);
      if (server->socket < 0)
        return server->error;
    }
  }
  return SOAP_OK;
}

int
server_connect(struct soap *server, const char *endpoint, const char *action, const char *userid, const char *passwd)
{ if (action && *action)
  { struct t__RoutingTable route;
    route.__ptr = NULL;
    route.__size = 0;
    fprintf(stderr, "Searching services on action %s...\n", action);
    while (lookup(&route, action, userid, passwd))
    { fprintf(stderr, "Attempting to connect to '%s'\n", route.__ptr->endpoint);
      if (!make_connect(server, route.__ptr->endpoint))
        return SOAP_OK;
    }
  }
  if (endpoint && *endpoint)
  { struct t__RoutingTable route;
    route.__ptr = NULL;
    route.__size = 0;
    fprintf(stderr, "Searching services on endpoint %s...\n", endpoint);
    while (lookup(&route, endpoint, userid, passwd))
    { fprintf(stderr, "Attempting to connect to '%s'\n", route.__ptr->endpoint);
      if (!make_connect(server, route.__ptr->endpoint))
        return SOAP_OK;
    }
  }
  if (connect_flag && endpoint && *endpoint)
  { fprintf(stderr, "Connect to endpoint %s...\n", endpoint);
    if (!make_connect(server, endpoint))
      return SOAP_OK;
  }
  return server->error = SOAP_TCP_ERROR;
}

int
copy_header(struct soap *sender, struct soap *receiver, const char *endpoint, const char *action)
{ struct header *h, *p;
  char *s, *t;
  h = (struct header*)SOAP_MALLOC(sender, sizeof(struct header));
  for (;;)
  { if (soap_getline(sender, h->line, SOAP_HDRLEN))
    { SOAP_FREE(sender, h);
      return sender->error = SOAP_EOF;
    }
    t = strchr(h->line, ' ');
    if (!t || strncmp(t, " 100 ", 5))
      break;
    do
    { if (soap_getline(sender, h->line, SOAP_HDRLEN))
      { SOAP_FREE(sender, h);
        return sender->error = SOAP_EOF;
      }
    } while (*h->line); 
  }
  p = h;
  for (;;)
  { p = p->next = (struct header*)SOAP_MALLOC(sender, sizeof(struct header));
    p->next = NULL;
    if (soap_getline(sender, p->line, SOAP_HDRLEN))
    { while (h)
      { p = h->next;
        SOAP_FREE(sender, h);
        h = p;
      }
      return sender->error = SOAP_EOF;
    }
    if (!*p->line)
      break;
    s = t = strchr(p->line, ':');
    if (t)
    { *t = '\0';
      do t++;
      while (*t && *t <= 32);
    }
    sender->fparsehdr(sender, p->line, t);
    if (s)
      *s = ':';
  }
  s = strstr(h->line, "HTTP/");
  if (s && (!strncmp(h->line, "GET ", 4) || !strncmp(h->line, "POST ", 5)))
  { size_t m = strlen(sender->endpoint);
    size_t n = m + (s - h->line) - 5 - (*h->line == 'P');
    if (n >= sizeof(sender->endpoint))
      n = sizeof(sender->endpoint) - 1;
    strncpy(sender->path, h->line + 4 + (*h->line == 'P'), n - m);
    sender->path[n - m] = '\0';
    strcat(sender->endpoint, sender->path);
  }
  if (!endpoint || !*endpoint)
    endpoint = sender->endpoint;
  if (!action || !*action)
    action = sender->action;
  if (server_connect(receiver, endpoint, action, receiver->userid, receiver->passwd))
  { while (h)
    { p = h->next;
      SOAP_FREE(sender, h);
      h = p;
    }
    return receiver->error;
  }
  receiver->count = sender->length;
  soap_begin_send(receiver);
  receiver->mode &= ~SOAP_IO;
  receiver->mode |= SOAP_IO_BUFFER;
  while (h)
  { receiver->fposthdr(receiver, h->line, NULL);
    p = h->next;
    SOAP_FREE(sender, h);
    h = p;
  }
  if ((sender->mode & SOAP_IO) == SOAP_IO_CHUNK)
  { if (soap_flush(receiver))
      return receiver->error;
    receiver->mode &= ~SOAP_IO;
    receiver->mode |= SOAP_IO_CHUNK;
  }
  return SOAP_OK;
}

int
create_header(struct soap *server, int method, const char *endpoint, const char *action, size_t count)
{ if (server_connect(server, endpoint, action, NULL, NULL))
    return server->error;
  soap_begin_send(server);
  server->mode &= ~SOAP_IO;
  server->mode |= SOAP_IO_BUFFER;
  server->status = method;
  return server->error = server->fpost(server, server->endpoint, server->host, server->port, server->path, action, count);
}

int
buffer_body(struct soap *sender)
{ char *s;
  if (soap_new_block(sender))
    return sender->error;
  for (;;)
  { if (!(s = (char*)soap_push_block(sender, sender->buflen - sender->bufidx)))
      return SOAP_EOM;
    memcpy(s, sender->buf + sender->bufidx, sender->buflen - sender->bufidx);
    if (soap_recv_raw(sender))
      break;
  }
  if (soap_end_recv(sender))
    return sender->error;
  sender->length = sender->blist->size;
  return SOAP_OK;
}

int
copy_body(struct soap *sender, struct soap *receiver)
{ if (sender->blist)
  { char *p;
    for (p = soap_first_block(sender); p; p = soap_next_block(sender))
      soap_send_raw(receiver, p, soap_block_size(sender));
    soap_end_block(sender);
  }
  else
  { if ((sender->mode & SOAP_IO) == SOAP_IO_CHUNK)
    { sender->chunkbuflen = sender->buflen;
      sender->buflen = sender->bufidx;
      sender->chunksize = 0;
      while (!soap_recv_raw(sender))
      { if (soap_send_raw(receiver, sender->buf + sender->bufidx, sender->buflen - sender->bufidx))
          return receiver->error;
      }
    }
    else
    { soap_send_raw(receiver, sender->buf + sender->bufidx, sender->buflen - sender->bufidx); /* send part after HTTP header */
      if (sender->buflen - sender->bufidx < sender->length)
      { sender->length -= sender->buflen - sender->bufidx;
        while (!soap_recv_raw(sender))
        { if (soap_send_raw(receiver, sender->buf, sender->buflen))
            return receiver->error;
	  if (sender->buflen >= sender->length)
	    break;
          sender->length -= sender->buflen;
        }
      }
    }
    if (soap_end_recv(sender))
      return sender->error;
  }
  if (soap_end_send(receiver))
    return receiver->error;
  return SOAP_OK;
}

struct Namespace namespaces[] =
{ {"SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/"},
  {"SOAP-ENC", "http://schemas.xmlsoap.org/soap/encoding/"},
  {"xsi", "http://www.w3.org/2001/XMLSchema-instance", "http://www.w3.org/*/XMLSchema-instance"},
  {"xsd", "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/*/XMLSchema"},
  {"t", "http://tempuri.org"},
  {NULL, NULL}
};