@@ -136,7 +136,7 @@ sbuf_ptr(sbuf *buf)

 }

 long

-sbuf_add(sbuf *buf, char *data, long datasize)

+sbuf_add(sbuf *buf, const char *data, long datasize)

 {

         long added;

         if(buf==NULL || data==NULL || buf->used==buf->size)

@@ -148,7 +148,7 @@ sbuf_add(sbuf *buf, char *data, long datasize)

 }

 long

-sbuf_addstr(sbuf *buf, char *str)

+sbuf_addstr(sbuf *buf, const char *str)

 {

         if(buf==NULL || str==NULL)

                 return(0);

@@ -41,8 +41,8 @@ void sbuf_wipe(sbuf *buf);

 char *sbuf_getbytes(sbuf *buf, long numbytes);

 long sbuf_count(sbuf *buf);

 char *sbuf_ptr(sbuf *buf);

-long sbuf_add(sbuf *buf, char *data, long datasize);

-long sbuf_addstr(sbuf *buf, char *str);

+long sbuf_add(sbuf *buf, const char *data, long datasize);

+long sbuf_addstr(sbuf *buf, const char *str);

 long sbuf_unused(sbuf *buf);

 char *sbuf_ptrunused(sbuf *buf);

 long sbuf_addfromunused(sbuf *buf, long numbytes);

@@ -12,6 +12,9 @@

 #include <stdlib.h>

 #include <unistd.h>

 #include <string.h>

+#include <sys/types.h>

+#include <sys/stat.h>

+#include <fcntl.h>

 #include "sbuf.h"

 #include "socklib.h"

 #include "webkernel.h"

@@ -34,8 +37,10 @@ typedef struct wk_client {

         int usedoutbufids;

         int outbufids[MAXOUTBUF];

         int serviced;

-        wk_uri uri;

         int continuationactive;

+        int fdtoserve;

+        wk_uri uri;

+        int headerbufid;

         int keepalive;

 } wk_client;

@@ -78,7 +83,7 @@ static wk_client *wk_accept(_wk *web);

 static wk_client *wk_clientacquire(_wk *web);

 static int wk_clientrelease(_wk *web, int connid);

 static wk_client *wk_clientget(_wk *web, int connid);

-static void wk_clientserviceread(_wk *web, wk_client *client);

+static int wk_clientserviceread(_wk *web, wk_client *client);

 wk *

 wk_init(int port, sselect *ssel, void (*callback_event)(/*wk *web,int connid, wk_event event, void *userptr*/), wk_action (*callback_http)(/*wk *web,int connid, wk_uri *uri, void *userptr*/), wk_action (*callback_continuation)(/*wk *web,int connid, wk_uri *uri, void *userptr*/), void *userptr)

@@ -144,6 +149,8 @@ wk_free(wk *paramweb)

                                         FD_CLR(client->fd,&(web->fdset));

                                         close(client->fd),client->fd=-1;

                                 }

+                                if(client->fdtoserve!=-1)

+                                        close(client->fdtoserve),client->fdtoserve=-1;

                         }

                 }

                 cb->usedclients=0;

@@ -190,7 +197,7 @@ wk_service(wk *paramweb)

 {

         int fds[FDBLOCK];

         int fd;

-        int n,i,k;

+        int n,i;

         sbuf *in;

         sbuf *out;

         _wk *web=(_wk *)paramweb;

@@ -221,10 +228,14 @@ wk_service(wk *paramweb)

                         }

                         if(sbuf_fill(in,fd,sock_queued(fd))==0) {

                                 /* client has closed connection */

-                                wk_close((wk *) web, fd);

+                                wk_close((wk *) web, client->connid);

+                                continue;

+                        }

+                        if(wk_clientserviceread(web,client)==-1) {

+                                /* internal error, protocol error or no enough memory */

+                                wk_close((wk *) web, client->connid);

                                 continue;

                         }

-                        wk_clientserviceread(web,client);

                 }

         }

         while((n=sselect_getwritefiltered(web,&(web->fdset),fds,sizeof(fds)/sizeof(fds[0])))>0) {

@@ -232,21 +243,30 @@ wk_service(wk *paramweb)

                         fd=fds[i];

                         if((client=(wk_client *)sselect_getuserptr(web->ssel,fd))==NULL || client->web!=(wk *)web)

                                 continue; /* internal error */

-                        for(out=NULL,k=client->usedoutbufids-1;k>=0;k--) {

-                                if((out=wk_sbufget((wk *) web,client->outbufids[k]))==NULL) {

-                                        k=-1;

-                                        break; /* internal error */

-                                }

-                        }

-                        if(k==-1 || out==NULL) {

+                        if((out=wk_sbufget((wk *) web,client->outbufids[0]))==NULL) {

                                 wk_close((wk *)web,client->connid);

                                 continue; /* internal error */

                         }

                         sbuf_send(out,fd,sbuf_count(out));

+                        /* if we are serving from file, load the next chunk */

+                        if(client->fdtoserve!=-1 && client->usedoutbufids==1) {

+                                sbuf_discard(out);

+                                if(sbuf_unused(out)>0) {

+                                        int n;

+                                        n=sbuf_fill(out,client->fdtoserve,sbuf_unused(out));

+                                        if(n<=0)

+                                                close(client->fdtoserve),client->fdtoserve=-1;

+                                }

+                        }

+                        /* free unused bufs, detect finished sending */

                         if(sbuf_count(out)==0) {

-                                if(k>0) {

+                                if(client->usedoutbufids>1) {

+                                        int sbufid;

+                                        sbufid=client->outbufids[0];

                                         client->usedoutbufids--;

-                                        wk_sbufrelease((wk *)web,client->outbufids[k]),client->outbufids[k]=-1;

+                                        memmove(client->outbufids,client->outbufids+1,sizeof(int)*(MAXOUTBUF-1));

+                                        client->outbufids[MAXOUTBUF-1]=-1;

+                                        wk_sbufrelease((wk *)web,sbufid),sbufid=-1;

                                 } else {

                                         sselect_delwrite(web->ssel,client->fd);

                                         if(client->continuationactive && web->callback_continuation!=NULL) {

@@ -266,29 +286,117 @@ wk_service(wk *paramweb)

 int

 wk_serve_buffer_as_file(wk *paramweb, int connid, void *data, int datalen, const char *mime)

 {

-

+        static const char *strcontenttype={"Content-Type: "};

+        _wk *web=(_wk *)paramweb;

+        wk_client *client;

+        char buf[256];

+        if(web==NULL)

+                return(-1);

+        if((client=wk_clientget(web,connid))==NULL)

+                return(-1);

+        wk_writestr((wk *)web,connid,"HTTP/1.1 200 OK\r\n");

+        sprintf(buf,"Content-Length: %i\r\n",datalen);

+        wk_writestr((wk *)web,connid,buf);

+        if(mime!=NULL && strlen(mime)<(sizeof(buf)-sizeof(strcontenttype)-3))

+                sprintf(buf,"%s%s\r\n",strcontenttype,mime);

+        else

+                sprintf(buf,"%s%s\r\n",strcontenttype,"application/octet-stream");

+        wk_writestr((wk *)web,connid,buf);

+        if(client->keepalive)

+                wk_writestr((wk *)web,connid,"Connection: keep-alive\r\n");

+        wk_writestr((wk *)web,connid,"\r\n");

+        return(wk_write((wk *)web,connid,data,datalen));

 }

 int

 wk_serve_file(wk *paramweb, int connid, char *filename, const char *mime)

 {

-

+        static const char *strcontenttype={"Content-Type: "};

+        _wk *web=(_wk *)paramweb;

+        wk_client *client;

+        char buf[256];

+        struct stat st;

+        if(web==NULL || filename==NULL)

+                return(-1);

+        if((client=wk_clientget(web,connid))==NULL)

+                return(-1);

+        if(client->fdtoserve!=-1)

+                close(client->fdtoserve),client->fdtoserve=-1;

+        if((client->fdtoserve=open(filename,O_RDONLY))==-1) {

+                wk_serve_error((wk *)web,connid,wkerr_notfound);

+                return(-1);

+        }

+        wk_writestr((wk *)web,connid,"HTTP/1.1 200 OK\r\n");

+        if(fstat(client->fdtoserve,&st)==0) {

+                sprintf(buf,"Content-Length: %lld\r\n",(long long)st.st_size);

+                wk_writestr((wk *)web,connid,buf);

+        } else

+                client->keepalive=0;

+        if(mime!=NULL && strlen(mime)<(sizeof(buf)-sizeof(strcontenttype)-3))

+                sprintf(buf,"%s%s\r\n",strcontenttype,mime);

+        else

+                sprintf(buf,"%s%s\r\n",strcontenttype,"application/octet-stream");

+        wk_writestr((wk *)web,connid,buf);

+        if(client->keepalive)

+                wk_writestr((wk *)web,connid,"Connection: keep-alive\r\n");

+        wk_writestr((wk *)web,connid,"\r\n");

+        return(0);

 }

 int

 wk_serve_error(wk *paramweb, int connid, wk_error wkerror)

 {

-

+        static const char strnotfound[]={"\

+HTTP/1.1 404 Not found\r\n\

+Content-Type: text/html\r\n\

+Content-Length: 113\r\n\

+\r\n\

+<title>404 Not Found</title>\r\n\

+<h1>404 Not Found</h1>\r\n\

+The requested resource could not be found on this server.\r\n\

+"};

+        static const char strinternal[]={"\

+HTTP/1.1 500 Internal Server Error\r\n\

+Content-Type: text/html\r\n\

+Content-Length: 118\r\n\

+\r\n\

+<title>500 Internal Server Error</title>\r\n\

+<h1>500 Internal Server Error</h1>\r\n\

+Internal error processing the request.\r\n\

+"};

+        static const char strnotimplemented[]={"\

+HTTP/1.1 501 Not Implemented\r\n\

+Content-Type: text/html\r\n\

+Content-Length: 132\r\n\

+\r\n\

+<title>501 Not Implemented</title>\r\n\

+<h1>501 Not Implemented</h1>\r\n\

+The request was not understood or is not allowed by this server.\r\n\

+"};

+        int res;

+        _wk *web=(_wk *)paramweb;

+        wk_client *client;

+        if(web==NULL)

+                return(-1);

+        if((client=wk_clientget(web,connid))==NULL)

+                return(-1);

+        if(wkerror==wkerr_notfound)

+                res=wk_write((wk *)web,connid,strnotfound,sizeof(strnotfound)-1);

+        else if(wkerror==wkerr_notimplemented)

+                res=wk_write((wk *)web,connid,strnotimplemented,sizeof(strnotimplemented)-1);

+        else

+                res=wk_write((wk *)web,connid,strinternal,sizeof(strinternal)-1);

+        return(res);

 }

 int

-wk_writestr(wk *paramweb, int connid, char *str)

+wk_writestr(wk *paramweb, int connid, const char *str)

 {

         return(wk_write(paramweb,connid,str,strlen(str)));

 }

 int

-wk_write(wk *paramweb, int connid, void *data, int datalen)

+wk_write(wk *paramweb, int connid, const void *data, int datalen)

 {

         int k;

         _wk *web=(_wk *)paramweb;

@@ -317,6 +425,8 @@ wk_write(wk *paramweb, int connid, void *data, int datalen)

                 datalen-=added;

                 total+=added;

         }

+        if(total>0)

+                sselect_addwrite(web->ssel,client->fd,(void *)client);

         return(total);

 }

@@ -335,6 +445,8 @@ wk_close(wk *paramweb, int connid)

                 FD_CLR(client->fd,&(web->fdset));

                 close(client->fd),client->fd=-1;

         }

+        if(client->fdtoserve!=-1)

+                close(client->fdtoserve),client->fdtoserve=-1;

         wk_clientrelease(web,connid);

         if(web->callback_event!=NULL)

                 web->callback_event((wk *)web,connid,wke_closed,web->userptr);

@@ -342,15 +454,32 @@ wk_close(wk *paramweb, int connid)

 }

 char *

-wk_uri_getheader(wk_uri *wkuri, char *header, char *defaultvalue)

+wk_uri_getheader(wk_uri *uri, char *header, char *defaultvalue)

 {

-

+        int n,len;

+        char *ptr;

+        if(uri==NULL || uri->headers==NULL || header==NULL)

+                return(NULL);

+        len=strlen(header);

+        for(n=0,ptr=uri->headers;*ptr!='\0';ptr++,n++) {

+                if(memcmp(ptr,header,len)==0 && ptr[len]==':' && ptr[len+1]==' ')

+                        return(ptr+len+2);

+        }

+        return(defaultvalue);

 }

 char *

-wk_uri_getheaderbynum(wk_uri *wkuri, int num)

+wk_uri_getheaderbynum(wk_uri *uri, int num)

 {

-

+        int n;

+        char *ptr;

+        if(uri==NULL || uri->headers==NULL)

+                return(NULL);

+        for(n=0,ptr=uri->headers;*ptr!='\0';ptr++,n++) {

+                if(n==num)

+                        return(ptr);

+        }

+        return(NULL);

 }

 const char *

@@ -584,6 +713,8 @@ wk_clientacquire(_wk *web)

                 return(NULL); /* insufficient memory */

         }

         client->usedoutbufids=1;

+        client->fdtoserve=-1;

+        client->headerbufid=-1;

         return(client);

 }

@@ -604,6 +735,8 @@ wk_clientrelease(_wk *web, int connid)

                 wk_sbufrelease((wk *)web,client->inbufid),client->inbufid=-1;

         for(w=0;w<client->usedoutbufids;w++)

                 wk_sbufrelease((wk *)web,client->outbufids[w]),client->outbufids[w]=-1;

+        if(client->headerbufid!=-1)

+                wk_sbufrelease((wk *)web,client->headerbufid),client->headerbufid=-1;

         memset(client,0,sizeof(wk_client));

         return(0);

 }

@@ -624,9 +757,98 @@ wk_clientget(_wk *web, int connid)

         return(web->clientblocks[numblock].clients+j);

 }

-static void

+static char *

+str_findfirstempty(char *ptr, int size)

+{

+        int i;

+        for(i=0;i<(size-3);i++) {

+                if(ptr[0]=='\r' && ptr[1]=='\n' && ptr[2]=='\r' && ptr[3]=='\n')

+                        return(ptr);

+        }

+        return(NULL);

+}

+

+static int

 wk_clientserviceread(_wk *web, wk_client *client)

 {

-#warning TODO

+        sbuf *in,*hbuf;

+        char *end;

+        char *ptr;

+        char *lineend;

+        char *sep;

+        wk_uri *uri;

+        /* check if we have all the headers */

+        if((in=wk_sbufget((wk *)web, client->inbufid))==NULL)

+                return(-1); /* internal error */

+        sbuf_discard(in);

+        if((end=str_findfirstempty(sbuf_ptr(in),sbuf_count(in)))==NULL) {

+                if(sbuf_unused(in)==0)

+                        return(-1); /* header part too long */

+                /* uncomplete headers, have to wait for more data */

+                return(0);

+        }

+        /* get memory for the uri data */

+        if(client->headerbufid!=-1)

+                wk_sbufrelease((wk *)web,client->headerbufid),client->headerbufid=-1;

+        if((client->headerbufid=wk_sbufacquire((wk *)web))==-1)

+                return(-1); /* insufficient memory */

+        if((hbuf=wk_sbufget((wk *)web,client->headerbufid))==NULL)

+                return(-1); /* internal error */

+        /* prepare to fill the uri struct */

+        uri=&(client->uri);

+        memset(uri,0,sizeof(wk_uri));

+        /* check that the method is supported */

+        ptr=sbuf_ptr(in);

+        if(memcmp(ptr,"GET ",4)!=0 && memcmp(ptr,"PUT ",4)!=0 && memcmp(ptr,"POST ",5)!=0)

+                return(-1); /* unknown method */

+        if((lineend=strchr(ptr,'\r'))!=NULL)

+                *lineend='\0';

+        else

+                lineend=end;

+        /* method */

+        sep=strchr(ptr,' ');

+        *sep='\0';

+        uri->method=sbuf_ptrunused(hbuf);

+        sbuf_add(hbuf,ptr,strlen(ptr)+1);

+        ptr+=strlen(ptr)+1;

+        /* path */

+        if((sep=strchr(ptr,' '))==NULL)

+                return(-1); /* no separator between path and protocol */

+        *sep='\0';

+        uri->path=sbuf_ptrunused(hbuf);

+        sbuf_add(hbuf,ptr,strlen(ptr)+1);

+        ptr+=strlen(ptr)+1;

+        /* protocol */

+        uri->path=sbuf_ptrunused(hbuf);

+        sbuf_add(hbuf,ptr,strlen(ptr)+1);

+        ptr+=strlen(ptr)+1;

+        /* headers */

+        *end='\0';

+        uri->headers=sbuf_ptrunused(hbuf);

+        client->keepalive=0;

+        while(ptr<end) {

+                if(*ptr!='\n')

+                        return(-1); /* line is not ended with \r\n */

+                ptr++;

+                if((lineend=strchr(ptr,'\r'))!=NULL)

+                        *lineend='\0';

+                else

+                        lineend=end;

+                if((sep=strchr(ptr,':'))==NULL || sep[1]!=' ')

+                        return(-1); /* header not in format "name: value" */

+                /* check for keepalive header */

+                if(memcmp(ptr,"Connection: ",12)==0 &&

+                  (strcmp(ptr+12,"keep-alive")==0 || strcmp(ptr+12,"Keep-Alive")==0))

+                        client->keepalive=1;

+                sbuf_add(hbuf,ptr,strlen(ptr)+1);

+                ptr+=strlen(ptr)+1;

+        }

+        /* add header terminator */

+        sbuf_add(hbuf,"",1);

+        /* call the http method */

+        client->serviced=1;

+        client->continuationactive=0;

+        client->continuationactive=web->callback_http((wk *)web, client->connid, uri, web->userptr);

+        return(0);

 }

@@ -53,8 +53,8 @@ int wk_service(wk *web); /* To be called after sselelect_wait() but before ssele

 int wk_serve_buffer_as_file(wk *web, int connid, void *data, int datalen, const char *mime);

 int wk_serve_file(wk *web, int connid, char *filename, const char *mime);

 int wk_serve_error(wk *web, int connid, wk_error wkerror);

-int wk_writestr(wk *web, int connid, char *str);

-int wk_write(wk *web, int connid, void *data, int datalen);

+int wk_writestr(wk *web, int connid, const char *str);

+int wk_write(wk *web, int connid, const void *data, int datalen);

 int wk_close(wk *web, int connid);

 char *wk_uri_getheader(wk_uri *wkuri, char *header, char *defaultvalue);