backend/cimxml/indicationlistener.c - third_party/sblim-sfcc - Git at Google


 /*
  * $\Id$
  *
  * © Copyright IBM Corp. 2007
  *
  * THIS FILE IS PROVIDED UNDER THE TERMS OF THE ECLIPSE PUBLIC LICENSE
  * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
  * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
  *
  * You can obtain a current copy of the Eclipse Public License from
  * http://www.opensource.org/licenses/eclipse-1.0.php
  *
  * Author:        Sven Schuetz <sven@de.ibm.com>
  *
  * Description:   indication listener implementation
  *                Most of the network and http code is taken from sfcb
  *                and written by Adrian Schuur / Viktor Mihajlovski
  */


 #include "nativeCimXml.h"
 #include "utilft.h"
 #include "cimXmlParser.h"

 #include <pthread.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <unistd.h>

 static int do_listen=1;

 #define SOCKBUFSZ 32768
 #define hdrBufsize 5000
 #define hdrLimmit 5000

 typedef struct _buffer {
    char *data, *content;
    int length, size, ptr, content_length,trailers;
    char *httpHdr, *authorization, *content_type, *host, *useragent;
    char *principal;
    char *protocol;
 } Buffer;

 typedef struct commHndl {
   int   socket;
   FILE *file;
   void *buf;
 } CommHndl;


 static void freeBuffer(Buffer * b)
 {
    Buffer emptyBuf = { NULL, NULL, 0, 0, 0, 0, 0 ,0};
    if (b->data)
       free(b->data);
    if (b->content)
       free(b->content);
    *b=emptyBuf;
 }


 int commWrite(CommHndl to, void *data, size_t count)
 {
    int rc=0;

     if (to.file == NULL) {
         rc = write(to.socket,data,count);
     } else {
         rc = fwrite(data,count,1,to.file);
         if (rc == 1) {
         /* return number of bytes written */
         rc = count;
         }
     }

     return rc;
 }

 int commRead(CommHndl from, void *data, size_t count)
 {
     int rc=0;

     rc = read(from.socket,data,count);

     return rc;
 }

 void commClose(CommHndl hndl)
 {
     if (hndl.file == NULL) {
         close(hndl.socket);
     } else {
         fclose(hndl.file);
         if (hndl.buf) {
             free(hndl.buf);
         }
     }
 }

 void commFlush(CommHndl hndl)
 {
     if (hndl.file) {
         fflush(hndl.file);
     }
 }

 static void add2buffer(Buffer * b, char *str, size_t len)
 {
    if (b->size == 0) {
       b->size = len + 500;
       b->length = 0;
       b->data = (char *) malloc(b->size);
    }
    else if (b->length + len >= b->size) {
       b->size = b->length + len + 500;
       b->data = (char *) realloc((void *) b->data, b->size);
    }
    memmove(&((b->data)[b->length]), str, len);
    b->length += len;
    (b->data)[b->length] = 0;
 }

 static void genError(CommHndl conn_fd, Buffer * b, int status, char *title,
                      char *more)
 {
     char head[1000];
     char server[] = "Server: sfcc indListener\r\n";
     char clength[] = "Content-Length: 0\r\n";
     char cclose[] = "Connection: close\r\n";
     char end[] = "\r\n";

     snprintf(head, sizeof(head), "%s %d %s\r\n", b->protocol, status, title);
     commWrite(conn_fd, head, strlen(head));
     if (more) {
         commWrite(conn_fd, more, strlen(more));
     }
     commWrite(conn_fd, server, strlen(server));
     commWrite(conn_fd, clength, strlen(clength));
     commWrite(conn_fd, cclose, strlen(cclose));

     commWrite(conn_fd, end, strlen(end));
     commFlush(conn_fd);
 }

 static char *getNextHdr(Buffer * b)
 {
     int i;
     char c;

     for (i = b->ptr; b->ptr < b->length; ++b->ptr) {
         c = b->data[b->ptr];
         if (c == '\n' || c == '\r') {
             b->data[b->ptr] = 0;
             ++b->ptr;
             if (c == '\r' && b->ptr < b->length && b->data[b->ptr] == '\n') {
                 b->data[b->ptr] = 0;
                 ++b->ptr;
             }
             return &(b->data[i]);
         }
     }
     return NULL;
 }

 static int readData(CommHndl conn_fd, char *into, int length)
 {
     int c = 0, r;

     while (c < length) {
         r = commRead(conn_fd, into + c, length - c);
         if (r < 0 && (errno == EINTR || errno == EAGAIN)) {
             continue;
         }
         c += r;
     }
     return c;
 }

 static void getPayload(CommHndl conn_fd, Buffer * b)
 {
     int c = b->length - b->ptr;
     b->content = (char *) malloc(b->content_length + 8);
     if (c) memcpy(b->content, (b->data) + b->ptr, c);

     readData(conn_fd, (b->content) + c, b->content_length - c);
     *((b->content) + b->content_length) = 0;
 }

 static int  getHdrs(CommHndl conn_fd, Buffer * b, char *cmd)
 {
    int first=1,total=0,isReady;
    struct timeval httpTimeout;
    fd_set httpfds;
    int state=0;

    FD_ZERO(&httpfds);
    FD_SET(conn_fd.socket,&httpfds);
    httpTimeout.tv_sec=5;
    httpTimeout.tv_usec=0;
    isReady = select(conn_fd.socket+1,&httpfds,NULL,NULL,&httpTimeout);
    if (isReady == 0) return 3;

    for (;;) {
       char buf[hdrBufsize];
       int r = commRead(conn_fd, buf, sizeof(buf));

       if (r < 0 && (errno == EINTR || errno == EAGAIN)) continue;
       if (r <= 0) break;

       add2buffer(b, buf, r);
       total+=r;
       if (r && first) {
          if (strncasecmp(buf,cmd,strlen(cmd)) != 0) {
        /* not what we expected - still continue to read to
           not confuse the client */
        state = 1;
      }
          first=0;
       }

       if (strstr(b->data, "\r\n\r\n") != NULL ||
           strstr(b->data, "\n\n") != NULL) {
          break;
       }

       if (total>=hdrLimmit) {
         fprintf(stderr, "-#- Possible DOS attempt detected\n");
         state = 2;
         break;
       }
    }
    return state;
 }

 static void processIndication(struct native_indicationlistener *i, char *xml)
 {
     ResponseHdr rh;

     CIMCInstance *inst;

     rh = scanCimXmlResponse(xml, NULL);

     if (rh.errCode != 0) {
         free(rh.description);
         rh.rvArray->ft->release(rh.rvArray);
         return;
     }

     inst = (CIMCInstance*)rh.rvArray->ft->getElementAt(rh.rvArray, 0, NULL).value.inst;

     if(inst) {
         i->sendIndicationInstance(inst->ft->clone(inst, NULL));
     }

     rh.rvArray->ft->release(rh.rvArray);
 }

 static void handleConnection(int connFd, struct native_indicationlistener *i)
 {
     Buffer inBuf = { NULL, NULL, 0, 0, 0, 0, 0 ,0};
     int badReq = 0;
     int discardInput=0;
     char *path, *hdr;
     char *cp;
     CommHndl conn_fd;
     int rc;

     inBuf.authorization = "";
     inBuf.protocol="HTTP/1.1";
     inBuf.content_type = NULL;
     inBuf.content_length = -1;
     inBuf.host = NULL;
     inBuf.useragent = "";

     conn_fd.socket=connFd;
     conn_fd.file=fdopen(connFd,"a");
     conn_fd.buf = NULL;
     if (conn_fd.file == NULL) {
         /* failed to create socket stream - continue with raw socket */
     } else {
         conn_fd.buf = malloc(SOCKBUFSZ);
     if (conn_fd.buf) {
         setbuffer(conn_fd.file,conn_fd.buf,SOCKBUFSZ);
     } else {
            /* failed to create socket buffer - continue unbuffered */
         }
     }

     rc=getHdrs(conn_fd, &inBuf,"POST ");

     if (rc==1) {
         genError(conn_fd, &inBuf, 501, "Not Implemented", NULL);
         /* we continue to parse headers and empty the socket
         to be graceful with the client */
         discardInput=1;
     }
     else if (rc==2) {
         genError(conn_fd, &inBuf, 400, "Bad Request", NULL);
         discardInput=2;
         /* potential DOS attempt discovered */
     }
     else if (rc==3) {
         genError(conn_fd, &inBuf, 400, "Bad Request", NULL);
         /* exiting after request timeout */
         commClose(conn_fd);
         exit(1);
     }

     if (inBuf.size == 0) {
         /* no buffer data - end of file - quit */
         commClose(conn_fd);
         exit(1);
     }

     inBuf.httpHdr = getNextHdr(&inBuf);
     for (badReq = 1;;) {
         if (inBuf.httpHdr == NULL) {
             break;
         }
         path = strpbrk(inBuf.httpHdr, " \t\r\n");
         if (path == NULL) {
             break;
         }
         *path++ = 0;
         path += strspn(path, " \t\r\n");
         inBuf.protocol = strpbrk(path, " \t\r\n");
         *inBuf.protocol++ = 0;
         if (inBuf.protocol == NULL) {
             break;
         }
         badReq = 0;
     }

     while ((hdr = getNextHdr(&inBuf)) != NULL) {
         if (hdr[0] == 0) {
             break;
         }
         else if (strncasecmp(hdr, "Authorization:", 14) == 0) {
             cp = &hdr[14];
             cp += strspn(cp, " \t");
             inBuf.authorization = cp;
         }
         else if (strncasecmp(hdr, "Content-Length:", 15) == 0) {
             cp = &hdr[15];
             cp += strspn(cp, " \t");
             inBuf.content_length = atol(cp);
         }
         else if (strncasecmp(hdr, "Content-Type:", 13) == 0) {
             cp = &hdr[13];
             cp += strspn(cp, " \t");
             inBuf.content_type = cp;
         }
         else if (strncasecmp(hdr, "Host:", 5) == 0) {
             cp = &hdr[5];
             cp += strspn(cp, " \t");
             inBuf.host = cp;
             if (strchr(inBuf.host, '/') != NULL || inBuf.host[0] == '.') {
                 if (!discardInput) {
                     genError(conn_fd, &inBuf, 400, "Bad Request", NULL);
                     discardInput=2;
                 }
             }
         }
         else if (strncasecmp(hdr, "User-Agent:", 11) == 0) {
             cp = &hdr[11];
             cp += strspn(cp, " \t");
             inBuf.useragent = cp;
         }
         else if (strncasecmp(hdr, "TE:", 3) == 0) {
             char *cp = &hdr[3];
             cp += strspn(cp, " \t");
             if (strncasecmp(cp,"trailers",8)==0)
             inBuf.trailers=1;
         }
         else if (strncasecmp(hdr, "Expect:", 7) == 0) {
             if (!discardInput) {
                 genError(conn_fd, &inBuf, 417, "Expectation Failed", NULL);
                 discardInput=2;
             }
         }
     }

     if (inBuf.content_length < 0) {
         if (!discardInput) {
             genError(conn_fd, &inBuf, 411, "Length Required", NULL);
         }
         commClose(conn_fd);
         exit(1);
     }

     getPayload(conn_fd, &inBuf);
     if (discardInput) {
         freeBuffer(&inBuf);
         return;
     }

     /* well, not really an error ... op successful */
     genError(conn_fd, &inBuf, 200, "OK", NULL);

     processIndication(i, inBuf.content);

     freeBuffer(&inBuf);
     free(conn_fd.buf);
 }

 static void* establish_listener(int sslMode, int port, struct native_indicationlistener *i)
 {
     struct sockaddr_in sin;
     socklen_t sz,sin_len;
     int listenFd, connFd;
     int ru;
     struct timeval timeout;
     fd_set socksset;
     int dataRead;
     char *xml;

     listenFd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
     sin_len = sizeof(sin);

     memset(&sin, 0, sin_len);
     sin.sin_family = AF_INET;
     sin.sin_addr.s_addr = INADDR_ANY;
     sin.sin_port = htons(port);

     ru = 1;
     setsockopt(listenFd, SOL_SOCKET, SO_REUSEADDR, (char *) &ru, sizeof(ru));

     if (bind(listenFd, (struct sockaddr *) &sin, sin_len) ||
         listen(listenFd, 0)) {
       exit(0);
     }

     sz = sizeof(sin);
     listen(listenFd, 1);

     while(do_listen) {

         timeout.tv_sec = 3;
         timeout.tv_usec = 0;
         FD_ZERO(&socksset);
         FD_SET(listenFd,&socksset);

         dataRead = select(listenFd+1, &socksset, NULL, NULL, &timeout);

         if(dataRead < 0) {
             fprintf(stderr, "Error during select(), return value was: %d\n", dataRead);
         }
         else if(dataRead == 0) {
             /* timed out, trying again */
         } else {
             if ((connFd = accept(listenFd, (__SOCKADDR_ARG) & sin, &sz))<0) {
                 fprintf(stderr, "Error during accept(), return value was: %d\n", connFd);
                 exit(0);
             }
             handleConnection(connFd, i);
             close(connFd);
         }
     }

     return NULL;
 }

 static void* start_listen_thread(void *parms)
 {
     struct native_indicationlistener* i;
     i = (struct native_indicationlistener*) parms;
     establish_listener(i->sslMode, i->port, i);
     return NULL;
 }

 static CIMCStatus _ilft_release(CIMCIndicationListener* il)
 {
     struct native_indicationlistener* i = (struct native_indicationlistener*)
                                           il;

     if(i) {
         free(i);
     }
     CIMCStatus ret;
     ret.rc = CIMC_RC_OK;
     ret.msg = NULL;
     return ret;
 }

 static CIMCIndicationListener* _ilft_clone(CIMCIndicationListener* il,
                                            CIMCStatus* rc)
 {
     /* not yet implemented. function is just here to comply with the default
      * function tables. it is questionable if a clone is needed for an
      * indication listener */
     return NULL;
 }

 static CIMCStatus _ilft_start(CIMCIndicationListener* il)
 {
     pthread_t id;
     struct native_indicationlistener* i;

     i = (struct native_indicationlistener*) il;

     do_listen = 1;

     pthread_create(&id, NULL, &start_listen_thread, i);

     CIMCStatus ret;
     ret.rc = CIMC_RC_OK;
     ret.msg = NULL;
     return ret;
 }

 static CIMCStatus _ilft_stop(CIMCIndicationListener* il)
 {
     do_listen = 0;

     CIMCStatus ret;
     ret.rc = CIMC_RC_OK;
     ret.msg = NULL;
     return ret;
 }

 CIMCIndicationListener *newCIMCIndicationListener(int sslMode,
                                                   int *portNumber,
                                                   void (*fp) (CIMCInstance *indInstance),
                                                   CIMCStatus *rc)
 {
     static CIMCIndicationListenerFT ilft = {
         NATIVECIMXML_FT_VERSION,
         _ilft_release,
         _ilft_clone,
         _ilft_start,
         _ilft_stop
     };

     static CIMCIndicationListener il = {
         "CIMCIndicationListener",
         &ilft
     };

     struct native_indicationlistener  * indicationlistener =
                 (struct native_indicationlistener*) calloc(1,
                    sizeof(struct native_indicationlistener));

     indicationlistener->il = il;
     indicationlistener->port = *portNumber;
     indicationlistener->sslMode = sslMode;
     indicationlistener->sendIndicationInstance = fp;

     return (CIMCIndicationListener*) indicationlistener;
 }

	/*
	* $\Id$
	*
	* © Copyright IBM Corp. 2007
	*
	* THIS FILE IS PROVIDED UNDER THE TERMS OF THE ECLIPSE PUBLIC LICENSE
	* ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
	* CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
	*
	* You can obtain a current copy of the Eclipse Public License from
	* http://www.opensource.org/licenses/eclipse-1.0.php
	*
	* Author: Sven Schuetz <sven@de.ibm.com>
	*
	* Description: indication listener implementation
	* Most of the network and http code is taken from sfcb
	* and written by Adrian Schuur / Viktor Mihajlovski
	*/


	#include "nativeCimXml.h"
	#include "utilft.h"
	#include "cimXmlParser.h"

	#include <pthread.h>
	#include <sys/socket.h>
	#include <netinet/in.h>
	#include <fcntl.h>
	#include <errno.h>
	#include <unistd.h>

	static int do_listen=1;

	#define SOCKBUFSZ 32768
	#define hdrBufsize 5000
	#define hdrLimmit 5000

	typedef struct _buffer {
	char data, content;
	int length, size, ptr, content_length,trailers;
	char httpHdr, authorization, content_type, host, *useragent;
	char *principal;
	char *protocol;
	} Buffer;

	typedef struct commHndl {
	int socket;
	FILE *file;
	void *buf;
	} CommHndl;


	static void freeBuffer(Buffer * b)
	{
	Buffer emptyBuf = { NULL, NULL, 0, 0, 0, 0, 0 ,0};
	if (b->data)
	free(b->data);
	if (b->content)
	free(b->content);
	*b=emptyBuf;
	}


	int commWrite(CommHndl to, void *data, size_t count)
	{
	int rc=0;

	if (to.file == NULL) {
	rc = write(to.socket,data,count);
	} else {
	rc = fwrite(data,count,1,to.file);
	if (rc == 1) {
	/* return number of bytes written */
	rc = count;
	}
	}

	return rc;
	}

	int commRead(CommHndl from, void *data, size_t count)
	{
	int rc=0;

	rc = read(from.socket,data,count);

	return rc;
	}

	void commClose(CommHndl hndl)
	{
	if (hndl.file == NULL) {
	close(hndl.socket);
	} else {
	fclose(hndl.file);
	if (hndl.buf) {
	free(hndl.buf);
	}
	}
	}

	void commFlush(CommHndl hndl)
	{
	if (hndl.file) {
	fflush(hndl.file);
	}
	}

	static void add2buffer(Buffer * b, char *str, size_t len)
	{
	if (b->size == 0) {
	b->size = len + 500;
	b->length = 0;
	b->data = (char *) malloc(b->size);
	}
	else if (b->length + len >= b->size) {
	b->size = b->length + len + 500;
	b->data = (char ) realloc((void ) b->data, b->size);
	}
	memmove(&((b->data)[b->length]), str, len);
	b->length += len;
	(b->data)[b->length] = 0;
	}

	static void genError(CommHndl conn_fd, Buffer * b, int status, char *title,
	char *more)
	{
	char head[1000];
	char server[] = "Server: sfcc indListener\r\n";
	char clength[] = "Content-Length: 0\r\n";
	char cclose[] = "Connection: close\r\n";
	char end[] = "\r\n";

	snprintf(head, sizeof(head), "%s %d %s\r\n", b->protocol, status, title);
	commWrite(conn_fd, head, strlen(head));
	if (more) {
	commWrite(conn_fd, more, strlen(more));
	}
	commWrite(conn_fd, server, strlen(server));
	commWrite(conn_fd, clength, strlen(clength));
	commWrite(conn_fd, cclose, strlen(cclose));

	commWrite(conn_fd, end, strlen(end));
	commFlush(conn_fd);
	}

	static char getNextHdr(Buffer b)
	{
	int i;
	char c;

	for (i = b->ptr; b->ptr < b->length; ++b->ptr) {
	c = b->data[b->ptr];
	if (c == '\n' \|\| c == '\r') {
	b->data[b->ptr] = 0;
	++b->ptr;
	if (c == '\r' && b->ptr < b->length && b->data[b->ptr] == '\n') {
	b->data[b->ptr] = 0;
	++b->ptr;
	}
	return &(b->data[i]);
	}
	}
	return NULL;
	}

	static int readData(CommHndl conn_fd, char *into, int length)
	{
	int c = 0, r;

	while (c < length) {
	r = commRead(conn_fd, into + c, length - c);
	if (r < 0 && (errno == EINTR \|\| errno == EAGAIN)) {
	continue;
	}
	c += r;
	}
	return c;
	}

	static void getPayload(CommHndl conn_fd, Buffer * b)
	{
	int c = b->length - b->ptr;
	b->content = (char *) malloc(b->content_length + 8);
	if (c) memcpy(b->content, (b->data) + b->ptr, c);

	readData(conn_fd, (b->content) + c, b->content_length - c);
	*((b->content) + b->content_length) = 0;
	}

	static int getHdrs(CommHndl conn_fd, Buffer * b, char *cmd)
	{
	int first=1,total=0,isReady;
	struct timeval httpTimeout;
	fd_set httpfds;
	int state=0;

	FD_ZERO(&httpfds);
	FD_SET(conn_fd.socket,&httpfds);
	httpTimeout.tv_sec=5;
	httpTimeout.tv_usec=0;
	isReady = select(conn_fd.socket+1,&httpfds,NULL,NULL,&httpTimeout);
	if (isReady == 0) return 3;

	for (;;) {
	char buf[hdrBufsize];
	int r = commRead(conn_fd, buf, sizeof(buf));

	if (r < 0 && (errno == EINTR \|\| errno == EAGAIN)) continue;
	if (r <= 0) break;

	add2buffer(b, buf, r);
	total+=r;
	if (r && first) {
	if (strncasecmp(buf,cmd,strlen(cmd)) != 0) {
	/* not what we expected - still continue to read to
	not confuse the client */
	state = 1;
	}
	first=0;
	}

	if (strstr(b->data, "\r\n\r\n") != NULL \|\|
	strstr(b->data, "\n\n") != NULL) {
	break;
	}

	if (total>=hdrLimmit) {
	fprintf(stderr, "-#- Possible DOS attempt detected\n");
	state = 2;
	break;
	}
	}
	return state;
	}

	static void processIndication(struct native_indicationlistener i, char xml)
	{
	ResponseHdr rh;

	CIMCInstance *inst;

	rh = scanCimXmlResponse(xml, NULL);

	if (rh.errCode != 0) {
	free(rh.description);
	rh.rvArray->ft->release(rh.rvArray);
	return;
	}

	inst = (CIMCInstance*)rh.rvArray->ft->getElementAt(rh.rvArray, 0, NULL).value.inst;

	if(inst) {
	i->sendIndicationInstance(inst->ft->clone(inst, NULL));
	}

	rh.rvArray->ft->release(rh.rvArray);
	}

	static void handleConnection(int connFd, struct native_indicationlistener *i)
	{
	Buffer inBuf = { NULL, NULL, 0, 0, 0, 0, 0 ,0};
	int badReq = 0;
	int discardInput=0;
	char path, hdr;
	char *cp;
	CommHndl conn_fd;
	int rc;

	inBuf.authorization = "";
	inBuf.protocol="HTTP/1.1";
	inBuf.content_type = NULL;
	inBuf.content_length = -1;
	inBuf.host = NULL;
	inBuf.useragent = "";

	conn_fd.socket=connFd;
	conn_fd.file=fdopen(connFd,"a");
	conn_fd.buf = NULL;
	if (conn_fd.file == NULL) {
	/* failed to create socket stream - continue with raw socket */
	} else {
	conn_fd.buf = malloc(SOCKBUFSZ);
	if (conn_fd.buf) {
	setbuffer(conn_fd.file,conn_fd.buf,SOCKBUFSZ);
	} else {
	/* failed to create socket buffer - continue unbuffered */
	}
	}

	rc=getHdrs(conn_fd, &inBuf,"POST ");

	if (rc==1) {
	genError(conn_fd, &inBuf, 501, "Not Implemented", NULL);
	/* we continue to parse headers and empty the socket
	to be graceful with the client */
	discardInput=1;
	}
	else if (rc==2) {
	genError(conn_fd, &inBuf, 400, "Bad Request", NULL);
	discardInput=2;
	/* potential DOS attempt discovered */
	}
	else if (rc==3) {
	genError(conn_fd, &inBuf, 400, "Bad Request", NULL);
	/* exiting after request timeout */
	commClose(conn_fd);
	exit(1);
	}

	if (inBuf.size == 0) {
	/* no buffer data - end of file - quit */
	commClose(conn_fd);
	exit(1);
	}

	inBuf.httpHdr = getNextHdr(&inBuf);
	for (badReq = 1;;) {
	if (inBuf.httpHdr == NULL) {
	break;
	}
	path = strpbrk(inBuf.httpHdr, " \t\r\n");
	if (path == NULL) {
	break;
	}
	*path++ = 0;
	path += strspn(path, " \t\r\n");
	inBuf.protocol = strpbrk(path, " \t\r\n");
	*inBuf.protocol++ = 0;
	if (inBuf.protocol == NULL) {
	break;
	}
	badReq = 0;
	}

	while ((hdr = getNextHdr(&inBuf)) != NULL) {
	if (hdr[0] == 0) {
	break;
	}
	else if (strncasecmp(hdr, "Authorization:", 14) == 0) {
	cp = &hdr[14];
	cp += strspn(cp, " \t");
	inBuf.authorization = cp;
	}
	else if (strncasecmp(hdr, "Content-Length:", 15) == 0) {
	cp = &hdr[15];
	cp += strspn(cp, " \t");
	inBuf.content_length = atol(cp);
	}
	else if (strncasecmp(hdr, "Content-Type:", 13) == 0) {
	cp = &hdr[13];
	cp += strspn(cp, " \t");
	inBuf.content_type = cp;
	}
	else if (strncasecmp(hdr, "Host:", 5) == 0) {
	cp = &hdr[5];
	cp += strspn(cp, " \t");
	inBuf.host = cp;
	if (strchr(inBuf.host, '/') != NULL \|\| inBuf.host[0] == '.') {
	if (!discardInput) {
	genError(conn_fd, &inBuf, 400, "Bad Request", NULL);
	discardInput=2;
	}
	}
	}
	else if (strncasecmp(hdr, "User-Agent:", 11) == 0) {
	cp = &hdr[11];
	cp += strspn(cp, " \t");
	inBuf.useragent = cp;
	}
	else if (strncasecmp(hdr, "TE:", 3) == 0) {
	char *cp = &hdr[3];
	cp += strspn(cp, " \t");
	if (strncasecmp(cp,"trailers",8)==0)
	inBuf.trailers=1;
	}
	else if (strncasecmp(hdr, "Expect:", 7) == 0) {
	if (!discardInput) {
	genError(conn_fd, &inBuf, 417, "Expectation Failed", NULL);
	discardInput=2;
	}
	}
	}

	if (inBuf.content_length < 0) {
	if (!discardInput) {
	genError(conn_fd, &inBuf, 411, "Length Required", NULL);
	}
	commClose(conn_fd);
	exit(1);
	}

	getPayload(conn_fd, &inBuf);
	if (discardInput) {
	freeBuffer(&inBuf);
	return;
	}

	/* well, not really an error ... op successful */
	genError(conn_fd, &inBuf, 200, "OK", NULL);

	processIndication(i, inBuf.content);

	freeBuffer(&inBuf);
	free(conn_fd.buf);
	}

	static void* establish_listener(int sslMode, int port, struct native_indicationlistener *i)
	{
	struct sockaddr_in sin;
	socklen_t sz,sin_len;
	int listenFd, connFd;
	int ru;
	struct timeval timeout;
	fd_set socksset;
	int dataRead;
	char *xml;

	listenFd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
	sin_len = sizeof(sin);

	memset(&sin, 0, sin_len);
	sin.sin_family = AF_INET;
	sin.sin_addr.s_addr = INADDR_ANY;
	sin.sin_port = htons(port);

	ru = 1;
	setsockopt(listenFd, SOL_SOCKET, SO_REUSEADDR, (char *) &ru, sizeof(ru));

	if (bind(listenFd, (struct sockaddr *) &sin, sin_len) \|\|
	listen(listenFd, 0)) {
	exit(0);
	}

	sz = sizeof(sin);
	listen(listenFd, 1);

	while(do_listen) {

	timeout.tv_sec = 3;
	timeout.tv_usec = 0;
	FD_ZERO(&socksset);
	FD_SET(listenFd,&socksset);

	dataRead = select(listenFd+1, &socksset, NULL, NULL, &timeout);

	if(dataRead < 0) {
	fprintf(stderr, "Error during select(), return value was: %d\n", dataRead);
	}
	else if(dataRead == 0) {
	/* timed out, trying again */
	} else {
	if ((connFd = accept(listenFd, (__SOCKADDR_ARG) & sin, &sz))<0) {
	fprintf(stderr, "Error during accept(), return value was: %d\n", connFd);
	exit(0);
	}
	handleConnection(connFd, i);
	close(connFd);
	}
	}

	return NULL;
	}

	static void* start_listen_thread(void *parms)
	{
	struct native_indicationlistener* i;
	i = (struct native_indicationlistener*) parms;
	establish_listener(i->sslMode, i->port, i);
	return NULL;
	}

	static CIMCStatus _ilft_release(CIMCIndicationListener* il)
	{
	struct native_indicationlistener* i = (struct native_indicationlistener*)
	il;

	if(i) {
	free(i);
	}
	CIMCStatus ret;
	ret.rc = CIMC_RC_OK;
	ret.msg = NULL;
	return ret;
	}

	static CIMCIndicationListener* _ilft_clone(CIMCIndicationListener* il,
	CIMCStatus* rc)
	{
	/* not yet implemented. function is just here to comply with the default
	* function tables. it is questionable if a clone is needed for an
	* indication listener */
	return NULL;
	}

	static CIMCStatus _ilft_start(CIMCIndicationListener* il)
	{
	pthread_t id;
	struct native_indicationlistener* i;

	i = (struct native_indicationlistener*) il;

	do_listen = 1;

	pthread_create(&id, NULL, &start_listen_thread, i);

	CIMCStatus ret;
	ret.rc = CIMC_RC_OK;
	ret.msg = NULL;
	return ret;
	}

	static CIMCStatus _ilft_stop(CIMCIndicationListener* il)
	{
	do_listen = 0;

	CIMCStatus ret;
	ret.rc = CIMC_RC_OK;
	ret.msg = NULL;
	return ret;
	}

	CIMCIndicationListener *newCIMCIndicationListener(int sslMode,
	int *portNumber,
	void (fp) (CIMCInstance indInstance),
	CIMCStatus *rc)
	{
	static CIMCIndicationListenerFT ilft = {
	NATIVECIMXML_FT_VERSION,
	_ilft_release,
	_ilft_clone,
	_ilft_start,
	_ilft_stop
	};

	static CIMCIndicationListener il = {
	"CIMCIndicationListener",
	&ilft
	};

	struct native_indicationlistener * indicationlistener =
	(struct native_indicationlistener*) calloc(1,
	sizeof(struct native_indicationlistener));

	indicationlistener->il = il;
	indicationlistener->port = *portNumber;
	indicationlistener->sslMode = sslMode;
	indicationlistener->sendIndicationInstance = fp;

	return (CIMCIndicationListener*) indicationlistener;
	}