/*

mtom-test.c

This application includes a MTOM test client and server. As a client
application, it fires four different base64 or MTOM attachments to the server.
As a server, it will respond to the messages by converting base64 into MTOM
attachments and vice versa.

Usage (server):
mtom-test <port>

Usage (client):
mtom-test http://localhost:<port> "<message>" "<MIME-type>"

Usage (client):
mtom-test http://localhost:<port> "<message>" "<MIME-type>" "<message2>" "<message3>" ...

--------------------------------------------------------------------------------
gSOAP XML Web services tools
Copyright (C) 2001-2004, Robert van Engelen, Genivia, Inc. All Rights Reserved.
This software is released under one of the following two licenses:
GPL or Genivia's license for commercial use.
--------------------------------------------------------------------------------
GPL license.

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place, Suite 330, Boston, MA 02111-1307 USA

Author contact information:
engelen@genivia.com / engelen@acm.org
--------------------------------------------------------------------------------
A commercial use license is available from Genivia, Inc., contact@genivia.com
--------------------------------------------------------------------------------
*/

#include "soapH.h"
#include "mtom_test.nsmap"

int cgi_serve();
int run_serve(int port);
int run_tests(int,char**);

int main(int argc, char **argv)
{ if (argc < 2)
    return cgi_serve();
  if (argc < 3)
    return run_serve(atoi(argv[1]));
  return run_tests(argc, argv);
}

int cgi_serve()
{ /* CGI-style: serve request from stdin */
  return soap_serve(soap_new1(SOAP_ENC_MTOM)); /* enable MTOM XOP attachments */
}

int run_serve(int port)
{ struct soap *soap = soap_new1(SOAP_ENC_MTOM);
  int ret;
  if (!soap_valid_socket(soap_bind(soap, NULL, port, 100)))
    soap_print_fault(soap, stderr);
  else
  { fprintf(stderr, "Bind to port %d successful\n", port);
    soap->accept_timeout = 3600; /* let server time out after one hour */
    for (;;)
    { int sock = soap_accept(soap);
      if (!soap_valid_socket(sock))
      { if (soap->errnum)
          soap_print_fault(soap, stderr);
        else
        { fprintf(stderr, "Server timed out\n");
          break;
        }
      }
      fprintf(stderr, "Accepting socket %d connection from IP %d.%d.%d.%d... ", sock, (int)(soap->ip>>24)&0xFF, (int)(soap->ip>>16)&0xFF, (int)(soap->ip>>8)&0xFF, (int)soap->ip&0xFF);
      if (soap_serve(soap))
        soap_print_fault(soap, stderr);
      fprintf(stderr, "done\n");
      soap_destroy(soap);
      soap_end(soap);
    } 
  }
  ret = soap->error;
  soap_done(soap);
  free(soap);
  return ret;
}

int run_tests(int argc, char **argv)
{ struct soap *soap = soap_new1(SOAP_ENC_MTOM);
  int i, ret;
  struct x__DataType data;
  struct x__WrapperType wrap;
  struct __m__EchoTestSingleResponse single;
  struct __m__EchoTestMultipleResponse multiple;
  soap_default_x__DataType(soap, &data);
  soap_default_x__WrapperType(soap, &wrap);

  /* First test call */
  data.__union = SOAP_UNION_x__data_base64;
  data.choice.base64.__ptr = (unsigned char*)argv[2];
  data.choice.base64.__size = (int)strlen(argv[2]) + 1;
  if (argc > 3)
    data.xmlmime__contentType = argv[3];
  if (soap_call___m__EchoTestSingle(soap, argv[1], NULL, &data, &single))
    soap_print_fault(soap, stderr);
  else
  { if (!single.x__Data || single.x__Data->__union != SOAP_UNION_x__data_xop__Include || !single.x__Data->choice.xop__Include.__ptr || single.x__Data->choice.xop__Include.__size != data.choice.base64.__size || strcmp((char*)single.x__Data->choice.xop__Include.__ptr, (char*)data.choice.base64.__ptr))
      fprintf(stderr, "EchoTestSingle 1: data transcription error\n");
    else
      fprintf(stderr, "EchoTestSingle 1: OK\n");
    /* Second test call */
    data.__union = SOAP_UNION_x__data_xop__Include;
    data.choice.xop__Include.__ptr = (unsigned char*)argv[2];
    data.choice.xop__Include.__size = (int)strlen(argv[2]) + 1;
    data.choice.xop__Include.id = NULL;
    data.choice.xop__Include.type = "text/xml; charset=utf-8";
    data.choice.xop__Include.options = NULL;
    if (soap_call___m__EchoTestSingle(soap, argv[1], NULL, &data, &single))
      soap_print_fault(soap, stderr);
    else
    { if (!single.x__Data
       || single.x__Data->__union != SOAP_UNION_x__data_base64
       || !single.x__Data->choice.base64.__ptr
       || single.x__Data->choice.base64.__size != data.choice.xop__Include.__size
       || strcmp((char*)single.x__Data->choice.base64.__ptr, (char*)data.choice.xop__Include.__ptr))
        fprintf(stderr, "EchoTestSingle 2: data transcription error\n");
      else
      { fprintf(stderr, "EchoTestSingle 2: OK\n");
        /* Third test call */
        wrap.__size = argc - 2;
        wrap.Data = (struct x__DataType*)soap_malloc(soap, wrap.__size * sizeof(struct x__DataType));
        for (i = 0; i < wrap.__size; ++i)
        { soap_default_x__DataType(soap, &wrap.Data[i]);
          wrap.Data[i].__union = SOAP_UNION_x__data_base64;
          wrap.Data[i].choice.base64.__ptr = (unsigned char*)argv[i + 2];
          wrap.Data[i].choice.base64.__size = (int)strlen(argv[i + 2]) + 1;
          wrap.Data[i].xmlmime__contentType = "text/xml";
        }
        if (soap_call___m__EchoTestMultiple(soap, argv[1], NULL, &wrap, &multiple))
          soap_print_fault(soap, stderr);
        else
        { int okay = 1;
          if (!multiple.x__EchoTest
	   || multiple.x__EchoTest->__size != wrap.__size)
            okay = 0;
          else
          { for (i = 0; i < multiple.x__EchoTest->__size; ++i)
              if (multiple.x__EchoTest->Data[i].__union != SOAP_UNION_x__data_xop__Include
	       || !multiple.x__EchoTest->Data[i].choice.xop__Include.__ptr
	       || multiple.x__EchoTest->Data[i].choice.xop__Include.__size != wrap.Data[i].choice.base64.__size
	       || strcmp((char*)multiple.x__EchoTest->Data[i].choice.xop__Include.__ptr, (char*)wrap.Data[i].choice.base64.__ptr))
                okay = 0;
          }
          if (!okay)
            fprintf(stderr, "EchoTestMultiple 1: data transcription error\n");
          else
          { fprintf(stderr, "EchoTestMultiple 1: OK\n");
            /* Fourth test call */
            for (i = 0; i < wrap.__size; ++i)
            { soap_default_x__DataType(soap, &wrap.Data[i]);
              wrap.Data[i].__union = SOAP_UNION_x__data_xop__Include;
              wrap.Data[i].choice.xop__Include.__ptr = (unsigned char*)argv[i + 2];
              wrap.Data[i].choice.xop__Include.__size = (int)strlen(argv[i + 2]) + 1;
              wrap.Data[i].choice.xop__Include.id = NULL;
              wrap.Data[i].choice.xop__Include.type = "text/xml";
              wrap.Data[i].choice.xop__Include.options = NULL;
              wrap.Data[i].xmlmime__contentType = "text/xml";
            }
            if (soap_call___m__EchoTestMultiple(soap, argv[1], NULL, &wrap, &multiple))
              soap_print_fault(soap, stderr);
            else
            { int okay = 1;
              if (!multiple.x__EchoTest
	       || multiple.x__EchoTest->__size != wrap.__size)
                okay = 0;
              else
              { for (i = 0; i < multiple.x__EchoTest->__size; ++i)
                  if (multiple.x__EchoTest->Data[i].__union != SOAP_UNION_x__data_base64
		   || !multiple.x__EchoTest->Data[i].choice.base64.__ptr
		   || multiple.x__EchoTest->Data[i].choice.base64.__size != wrap.Data[i].choice.xop__Include.__size || strcmp((char*)multiple.x__EchoTest->Data[i].choice.base64.__ptr, (char*)wrap.Data[i].choice.xop__Include.__ptr))
                    okay = 0;
              }
              if (!okay)
                fprintf(stderr, "EchoTestMultiple 2: data transcription error\n");
              else
                fprintf(stderr, "EchoTestMultiple 2: OK\n");
            }
          }
        }
      }
    }
  }
  ret = soap->error;
  soap_destroy(soap);
  soap_end(soap);
  soap_done(soap);
  free(soap);
  return ret;
}

int __m__EchoTestSingle(struct soap *soap, struct x__DataType *data, struct __m__EchoTestSingleResponse *response)
{ if (!data)
    return soap_sender_fault(soap, "No data", NULL);
  /* allocate response */
  response->x__Data = (struct x__DataType*)soap_malloc(soap, sizeof(struct x__DataType));
  if (!response->x__Data)
    return SOAP_EOM;
  /* copy data into response, switching from base64 to MTOM and vice versa */
  switch (data->__union)
  { case SOAP_UNION_x__data_xop__Include:
      /* convert MTOM attachment to base64Binary */
      response->x__Data->__union = SOAP_UNION_x__data_base64;
      response->x__Data->choice.base64.__ptr = data->choice.xop__Include.__ptr;
      response->x__Data->choice.base64.__size = data->choice.xop__Include.__size;
      response->x__Data->xmlmime__contentType = data->choice.xop__Include.type;
      break;
    case SOAP_UNION_x__data_base64:
      /* convert base64Binary to MTOM attachment */
      response->x__Data->__union = SOAP_UNION_x__data_xop__Include;
      response->x__Data->choice.xop__Include.__ptr = data->choice.base64.__ptr;
      response->x__Data->choice.xop__Include.__size = data->choice.base64.__size;
      response->x__Data->choice.xop__Include.id = NULL;
      response->x__Data->choice.xop__Include.type = data->xmlmime__contentType;
      response->x__Data->choice.xop__Include.options = NULL;
      response->x__Data->xmlmime__contentType = data->xmlmime__contentType;
      break;
    default:
      return soap_sender_fault(soap, "Wrong data format", NULL);
  }
  return SOAP_OK;
}

int __m__EchoTestMultiple(struct soap *soap, struct x__WrapperType *x__EchoTest, struct __m__EchoTestMultipleResponse *response)
{ int i;
  if (!x__EchoTest)
    return soap_sender_fault(soap, "No data", NULL);
  /* allocate response */
  response->x__EchoTest = (struct x__WrapperType*)soap_malloc(soap, sizeof(struct x__WrapperType));
  if (!response->x__EchoTest)
    return SOAP_EOM;
  response->x__EchoTest->__size = x__EchoTest->__size;
  response->x__EchoTest->Data = (struct x__DataType*)soap_malloc(soap, sizeof(struct x__DataType) * x__EchoTest->__size);
  if (!response->x__EchoTest->Data)
    return SOAP_EOM;
  /* copy data into response, switching from base64 to MTOM and vice versa */
  for (i = 0; i < x__EchoTest->__size; ++i)
  { switch (x__EchoTest->Data[i].__union)
    { case SOAP_UNION_x__data_xop__Include:
        /* convert MTOM attachment to base64Binary */
        response->x__EchoTest->Data[i].__union = SOAP_UNION_x__data_base64;
        response->x__EchoTest->Data[i].choice.base64.__ptr = x__EchoTest->Data[i].choice.xop__Include.__ptr;
        response->x__EchoTest->Data[i].choice.base64.__size = x__EchoTest->Data[i].choice.xop__Include.__size;
        response->x__EchoTest->Data[i].xmlmime__contentType = x__EchoTest->Data[i].choice.xop__Include.type;
        break;
      case SOAP_UNION_x__data_base64:
        /* convert base64Binary to MTOM attachment */
        response->x__EchoTest->Data[i].__union = SOAP_UNION_x__data_xop__Include;
        response->x__EchoTest->Data[i].choice.xop__Include.__ptr = x__EchoTest->Data[i].choice.base64.__ptr;
        response->x__EchoTest->Data[i].choice.xop__Include.__size = x__EchoTest->Data[i].choice.base64.__size;
        response->x__EchoTest->Data[i].choice.xop__Include.id = NULL;
        response->x__EchoTest->Data[i].choice.xop__Include.type = x__EchoTest->Data[i].xmlmime__contentType;
        response->x__EchoTest->Data[i].choice.xop__Include.options = NULL;
        response->x__EchoTest->Data[i].xmlmime__contentType = x__EchoTest->Data[i].xmlmime__contentType;
        break;
      default:
        return soap_sender_fault(soap, "Wrong data format", NULL);
    }
  }
  return SOAP_OK;
}