Changeset 28790 for branches/backfire


Ignore:
Timestamp:
2011-11-06T22:17:42+01:00 (4 years ago)
Author:
jow
Message:

[backfire] merge all uhttpd changes from trunk

Location:
branches/backfire/package/uhttpd
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • branches/backfire/package/uhttpd/Makefile

    r28255 r28790  
    99 
    1010PKG_NAME:=uhttpd 
    11 PKG_RELEASE:=23.3 
     11PKG_RELEASE:=28 
    1212 
    1313PKG_BUILD_DIR := $(BUILD_DIR)/$(PKG_NAME) 
    14 PKG_BUILD_DEPENDS := libcyassl liblua 
     14PKG_CONFIG_DEPENDS := \ 
     15        CONFIG_PACKAGE_uhttpd-mod-lua \ 
     16        CONFIG_PACKAGE_uhttpd-mod-tls \ 
     17        CONFIG_PACKAGE_uhttpd-mod-tls_cyassl \ 
     18        CONFIG_PACKAGE_uhttpd-mod-tls_openssl 
    1519 
    1620include $(INCLUDE_DIR)/package.mk 
     
    1923  SECTION:=net 
    2024  CATEGORY:=Network 
     25  SUBMENU:=Web Servers/Proxies 
    2126  TITLE:=uHTTPd - tiny, single threaded HTTP server 
     27  MAINTAINER:=Jo-Philipp Wich <xm@subsignal.org> 
    2228endef 
    2329 
     
    3743  $(Package/uhttpd/default) 
    3844  TITLE+= (TLS plugin) 
    39   DEPENDS:=uhttpd +libcyassl 
     45  DEPENDS:=uhttpd +PACKAGE_uhttpd-mod-tls_cyassl:libcyassl +PACKAGE_uhttpd-mod-tls_openssl:libopenssl 
    4046endef 
    4147 
     
    4349 The TLS plugin adds HTTPS support to uHTTPd. 
    4450endef 
     51 
     52define Package/uhttpd-mod-tls/config 
     53        choice 
     54                depends on PACKAGE_uhttpd-mod-tls 
     55                prompt "TLS Provider" 
     56                default PACKAGE_uhttpd-mod-tls_cyassl 
     57 
     58                config PACKAGE_uhttpd-mod-tls_cyassl 
     59                        bool "CyaSSL" 
     60 
     61                config PACKAGE_uhttpd-mod-tls_openssl 
     62                        bool "OpenSSL" 
     63        endchoice 
     64endef 
     65 
     66UHTTPD_TLS:= 
     67TLS_CFLAGS:= 
     68TLS_LDFLAGS:= 
     69 
     70ifneq ($(CONFIG_PACKAGE_uhttpd-mod-tls_cyassl),) 
     71  UHTTPD_TLS:=cyassl 
     72  TLS_CFLAGS:=-I$(STAGING_DIR)/usr/include/cyassl -DTLS_IS_CYASSL 
     73  TLS_LDFLAGS:=-lcyassl -lm 
     74endif 
     75 
     76ifneq ($(CONFIG_PACKAGE_uhttpd-mod-tls_openssl),) 
     77  UHTTPD_TLS:=openssl 
     78  TLS_CFLAGS:=-DTLS_IS_OPENSSL 
     79  TLS_LDFLAGS:=-lssl 
     80endif 
    4581 
    4682 
     
    5692 
    5793 
    58 # hack to use CyASSL headers 
    59 TARGET_CFLAGS += -I$(firstword $(wildcard $(BUILD_DIR)/cyassl-*/include)) 
    60 TARGET_LDFLAGS += -lm 
    61 MAKE_VARS += FPIC="$(FPIC)" 
     94TARGET_CFLAGS += $(TLS_CFLAGS) 
     95TARGET_LDFLAGS += $(TLS_LDFLAGS) 
     96MAKE_VARS += \ 
     97        FPIC="$(FPIC)" \ 
     98        LUA_SUPPORT="$(if $(CONFIG_PACKAGE_uhttpd-mod-lua),1)" \ 
     99        TLS_SUPPORT="$(if $(CONFIG_PACKAGE_uhttpd-mod-tls),1)" \ 
     100        UHTTPD_TLS="$(UHTTPD_TLS)" \ 
     101        TLS_CFLAGS="$(TLS_CFLAGS)" \ 
     102        TLS_LDFLAGS="$(TLS_LDFLAGS)" 
    62103 
    63104define Build/Prepare 
  • branches/backfire/package/uhttpd/files/uhttpd.init

    r24953 r28790  
    4545                $PX5G_BIN selfsigned -der \ 
    4646                        -days ${days:-730} -newkey rsa:${bits:-1024} -keyout "$UHTTPD_KEY" -out "$UHTTPD_CERT" \ 
    47                         -subj /C=${country:-DE}/ST=${state:-Saxony}/L=${location:-Leipzig}/CN=${commonname:-OpenWrt} 
     47                        -subj /C="${country:-DE}"/ST="${state:-Saxony}"/L="${location:-Leipzig}"/CN="${commonname:-OpenWrt}" 
    4848        } 
    4949} 
  • branches/backfire/package/uhttpd/src/Makefile

    r20428 r28790  
    22LUA_SUPPORT ?= 1 
    33TLS_SUPPORT ?= 1 
     4UHTTPD_TLS ?= cyassl 
    45 
    5 CFLAGS ?= -I./lua-5.1.4/src -I./cyassl-1.4.0/include -O0 -ggdb3 
    6 LDFLAGS ?= -L./lua-5.1.4/src -L./cyassl-1.4.0/src/.libs 
     6CFLAGS ?= -I./lua-5.1.4/src $(TLS_CFLAGS) -O0 -ggdb3 
     7LDFLAGS ?= -L./lua-5.1.4/src 
    78 
    89CFLAGS += -Wall --std=gnu99 
    910 
    10 OBJ = uhttpd.o uhttpd-file.o uhttpd-utils.o 
    11 LIB = -Wl,--export-dynamic -lcrypt -ldl 
     11ifeq ($(UHTTPD_TLS),openssl) 
     12  TLS_LDFLAGS ?= -L./openssl-0.9.8m -lssl 
     13  TLS_CFLAGS ?= -I./openssl-0.9.8m/include -DTLS_IS_OPENSSL 
     14else 
     15  TLS_LDFLAGS ?= -L./cyassl-1.4.0/src/.libs -lcyassl 
     16  TLS_CFLAGS ?= -I./cyassl-1.4.0/include -DTLS_IS_CYASSL 
     17endif 
    1218 
    13 TLSLIB = 
    14 LUALIB = 
     19OBJ := uhttpd.o uhttpd-file.o uhttpd-utils.o 
     20LIB := -Wl,--export-dynamic -lcrypt -ldl 
     21 
     22TLSLIB := 
     23LUALIB := 
     24 
     25HAVE_SHADOW=$(shell echo 'int main(void){ return !getspnam("root"); }' | \ 
     26        $(CC) -include shadow.h -xc -o/dev/null - 2>/dev/null && echo yes) 
     27 
     28ifeq ($(HAVE_SHADOW),yes) 
     29  CFLAGS += -DHAVE_SHADOW 
     30endif 
     31 
     32ifeq ($(TLS_SUPPORT),1) 
     33  CFLAGS += -DHAVE_TLS 
     34endif 
     35 
     36ifeq ($(CGI_SUPPORT),1) 
     37  CFLAGS += -DHAVE_CGI 
     38endif 
     39 
     40ifeq ($(LUA_SUPPORT),1) 
     41  CFLAGS += -DHAVE_LUA 
     42endif 
    1543 
    1644 
     
    1947ifeq ($(CGI_SUPPORT),1) 
    2048  OBJ += uhttpd-cgi.o 
    21   CFLAGS += -DHAVE_CGI 
    2249endif 
    2350 
    2451ifeq ($(LUA_SUPPORT),1) 
    25   CFLAGS += -DHAVE_LUA 
    26   LUALIB = uhttpd_lua.so 
     52  LUALIB := uhttpd_lua.so 
    2753 
    2854  $(LUALIB): uhttpd-lua.c 
     
    3359 
    3460ifeq ($(TLS_SUPPORT),1) 
    35   CFLAGS += -DHAVE_TLS 
    36   TLSLIB = uhttpd_tls.so 
     61  TLSLIB := uhttpd_tls.so 
    3762 
    3863  $(TLSLIB): uhttpd-tls.c 
    3964                $(CC) $(CFLAGS) $(LDFLAGS) $(FPIC) \ 
    40                         -shared -lcyassl \ 
     65                        -shared $(TLS_LDFLAGS) \ 
    4166                        -o $(TLSLIB) uhttpd-tls.c 
    4267endif 
     
    5075clean: 
    5176        rm -f *.o *.so uhttpd 
    52  
  • branches/backfire/package/uhttpd/src/uhttpd-tls.c

    r22962 r28790  
    2121#include "uhttpd-utils.h" 
    2222 
     23#include <syslog.h> 
     24#define dbg(...) syslog(LOG_INFO, __VA_ARGS__) 
     25 
     26#ifdef TLS_IS_CYASSL 
     27static int uh_cyassl_recv_cb(char *buf, int sz, void *ctx) 
     28{ 
     29        int rv; 
     30        int socket = *(int *)ctx; 
     31        struct client *cl; 
     32 
     33        if (!(cl = uh_client_lookup(socket))) 
     34                return -1; /* unexpected error */ 
     35 
     36        rv = uh_tcp_recv_lowlevel(cl, buf, sz); 
     37 
     38        if (rv < 0) 
     39                return -4; /* interrupted */ 
     40 
     41        if (rv == 0) 
     42                return -5; /* connection closed */ 
     43 
     44        return rv; 
     45} 
     46 
     47static int uh_cyassl_send_cb(char *buf, int sz, void *ctx) 
     48{ 
     49        int rv; 
     50        int socket = *(int *)ctx; 
     51        struct client *cl; 
     52 
     53        if (!(cl = uh_client_lookup(socket))) 
     54                return -1; /* unexpected error */ 
     55 
     56        rv = uh_tcp_send_lowlevel(cl, buf, sz); 
     57 
     58        if (rv <= 0) 
     59                return -5; /* connection dead */ 
     60 
     61        return rv; 
     62} 
     63 
     64void SetCallbackIORecv_Ctx(SSL_CTX*, int (*)(char *, int, void *)); 
     65void SetCallbackIOSend_Ctx(SSL_CTX*, int (*)(char *, int, void *)); 
     66 
     67static void uh_tls_ctx_setup(SSL_CTX *ctx) 
     68{ 
     69        SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL); 
     70        SetCallbackIORecv_Ctx(ctx, uh_cyassl_recv_cb); 
     71        SetCallbackIOSend_Ctx(ctx, uh_cyassl_send_cb); 
     72        return; 
     73} 
     74 
     75static int uh_tls_client_ctx_setup(SSL *ssl, int socket) 
     76{ 
     77        return SSL_set_fd(ssl, socket); 
     78} 
     79#endif /* TLS_IS_CYASSL */ 
     80 
     81#ifdef TLS_IS_OPENSSL 
     82static long uh_openssl_bio_ctrl_cb(BIO *b, int cmd, long num, void *ptr) 
     83{ 
     84        long rv = 1; 
     85 
     86        switch (cmd) 
     87        { 
     88                case BIO_C_SET_FD: 
     89                        b->num      = *((int *)ptr); 
     90                        b->shutdown = (int)num; 
     91                        b->init     = 1; 
     92                        break; 
     93 
     94                case BIO_C_GET_FD: 
     95                        if (!b->init) 
     96                                return -1; 
     97 
     98                        if (ptr) 
     99                                *((int *)ptr) = b->num; 
     100 
     101                        rv = b->num; 
     102                        break; 
     103        } 
     104 
     105        return rv; 
     106} 
     107 
     108static int uh_openssl_bio_read_cb(BIO *b, char *out, int outl) 
     109{ 
     110        int rv = 0; 
     111        struct client *cl; 
     112 
     113        if (!(cl = uh_client_lookup(b->num))) 
     114                return -1; 
     115 
     116        if (out != NULL) 
     117                rv = uh_tcp_recv_lowlevel(cl, out, outl); 
     118 
     119        return rv; 
     120} 
     121 
     122static int uh_openssl_bio_write_cb(BIO *b, const char *in, int inl) 
     123{ 
     124        struct client *cl; 
     125 
     126        if (!(cl = uh_client_lookup(b->num))) 
     127                return -1; 
     128 
     129        return uh_tcp_send_lowlevel(cl, in, inl); 
     130} 
     131 
     132static BIO_METHOD uh_openssl_bio_methods = { 
     133        .type   = BIO_TYPE_SOCKET, 
     134        .name   = "uhsocket", 
     135        .ctrl   = uh_openssl_bio_ctrl_cb, 
     136        .bwrite = uh_openssl_bio_write_cb, 
     137        .bread  = uh_openssl_bio_read_cb 
     138}; 
     139 
     140static void uh_tls_ctx_setup(SSL_CTX *ctx) 
     141{ 
     142        SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL); 
     143        return; 
     144} 
     145 
     146static int uh_tls_client_ctx_setup(SSL *ssl, int socket) 
     147{ 
     148        BIO *b; 
     149 
     150        if (!(b = BIO_new(&uh_openssl_bio_methods))) 
     151                return 0; 
     152 
     153        BIO_set_fd(b, socket, BIO_NOCLOSE); 
     154        SSL_set_bio(ssl, b, b); 
     155 
     156        return 1; 
     157} 
     158#endif /* TLS_IS_OPENSSL */ 
     159 
    23160 
    24161SSL_CTX * uh_tls_ctx_init() 
    25162{ 
    26         SSL_CTX *c = NULL; 
     163        SSL_CTX *c; 
     164 
    27165        SSL_load_error_strings(); 
    28166        SSL_library_init(); 
    29167 
    30         if( (c = SSL_CTX_new(TLSv1_server_method())) != NULL ) 
    31                 SSL_CTX_set_verify(c, SSL_VERIFY_NONE, NULL); 
     168        if ((c = SSL_CTX_new(TLSv1_server_method())) != NULL) 
     169                uh_tls_ctx_setup(c); 
    32170 
    33171        return c; 
     
    60198 
    61199 
    62 void uh_tls_client_accept(struct client *c) 
    63 { 
     200int uh_tls_client_accept(struct client *c) 
     201{ 
     202        int rv; 
     203 
    64204        if( c->server && c->server->tls ) 
    65205        { 
    66206                c->tls = SSL_new(c->server->tls); 
    67                 SSL_set_fd(c->tls, c->socket); 
    68         } 
     207                if( c->tls ) 
     208                { 
     209                        if( (rv = uh_tls_client_ctx_setup(c->tls, c->socket)) < 1 ) 
     210                                goto cleanup; 
     211 
     212                        if( (rv = SSL_accept(c->tls)) < 1 ) 
     213                                goto cleanup; 
     214                } 
     215                else 
     216                        rv = 0; 
     217        } 
     218        else 
     219        { 
     220                c->tls = NULL; 
     221                rv = 1; 
     222        } 
     223 
     224done: 
     225        return rv; 
     226 
     227cleanup: 
     228        SSL_free(c->tls); 
     229        c->tls = NULL; 
     230        goto done; 
    69231} 
    70232 
     
    91253        } 
    92254} 
    93  
    94  
  • branches/backfire/package/uhttpd/src/uhttpd-tls.h

    r20428 r28790  
    2727void uh_tls_ctx_free(struct listener *l); 
    2828 
    29 void uh_tls_client_accept(struct client *c); 
     29int uh_tls_client_accept(struct client *c); 
    3030int uh_tls_client_recv(struct client *c, void *buf, int len); 
    3131int uh_tls_client_send(struct client *c, void *buf, int len); 
     
    3333 
    3434#endif 
    35  
  • branches/backfire/package/uhttpd/src/uhttpd-utils.c

    r24953 r28790  
    125125 
    126126 
    127 int uh_tcp_send(struct client *cl, const char *buf, int len) 
     127int uh_tcp_send_lowlevel(struct client *cl, const char *buf, int len) 
    128128{ 
    129129        fd_set writer; 
     
    136136        timeout.tv_usec = 0; 
    137137 
    138         if( select(cl->socket + 1, NULL, &writer, NULL, &timeout) > 0 ) 
    139         { 
     138        if (select(cl->socket + 1, NULL, &writer, NULL, &timeout) > 0) 
     139                return send(cl->socket, buf, len, 0); 
     140 
     141        return -1; 
     142} 
     143 
     144int uh_tcp_send(struct client *cl, const char *buf, int len) 
     145{ 
    140146#ifdef HAVE_TLS 
    141                 if( cl->tls ) 
    142                         return cl->server->conf->tls_send(cl, (void *)buf, len); 
     147        if (cl->tls) 
     148                return cl->server->conf->tls_send(cl, (void *)buf, len); 
     149        else 
     150#endif 
     151                return uh_tcp_send_lowlevel(cl, buf, len); 
     152} 
     153 
     154int uh_tcp_peek(struct client *cl, char *buf, int len) 
     155{ 
     156        /* sanity check, prevent overflowing peek buffer */ 
     157        if (len > sizeof(cl->peekbuf)) 
     158                return -1; 
     159 
     160        int sz = uh_tcp_recv(cl, buf, len); 
     161 
     162        /* store received data in peek buffer */ 
     163        if( sz > 0 ) 
     164        { 
     165                cl->peeklen = sz; 
     166                memcpy(cl->peekbuf, buf, sz); 
     167        } 
     168 
     169        return sz; 
     170} 
     171 
     172int uh_tcp_recv_lowlevel(struct client *cl, char *buf, int len) 
     173{ 
     174        fd_set reader; 
     175        struct timeval timeout; 
     176 
     177        FD_ZERO(&reader); 
     178        FD_SET(cl->socket, &reader); 
     179 
     180        timeout.tv_sec  = cl->server->conf->network_timeout; 
     181        timeout.tv_usec = 0; 
     182 
     183        if (select(cl->socket + 1, &reader, NULL, NULL, &timeout) > 0) 
     184                return recv(cl->socket, buf, len, 0); 
     185 
     186        return -1; 
     187} 
     188 
     189int uh_tcp_recv(struct client *cl, char *buf, int len) 
     190{ 
     191        int sz = 0; 
     192        int rsz = 0; 
     193 
     194        /* first serve data from peek buffer */ 
     195        if (cl->peeklen > 0) 
     196        { 
     197                sz = min(cl->peeklen, len); 
     198                len -= sz; cl->peeklen -= sz; 
     199                memcpy(buf, cl->peekbuf, sz); 
     200                memmove(cl->peekbuf, &cl->peekbuf[sz], cl->peeklen); 
     201        } 
     202 
     203        /* caller wants more */ 
     204        if (len > 0) 
     205        { 
     206#ifdef HAVE_TLS 
     207                if (cl->tls) 
     208                        rsz = cl->server->conf->tls_recv(cl, (void *)&buf[sz], len); 
    143209                else 
    144210#endif 
    145                         return send(cl->socket, buf, len, 0); 
    146         } 
    147  
    148         return -1; 
    149 } 
    150  
    151 int uh_tcp_peek(struct client *cl, char *buf, int len) 
    152 { 
    153         int sz = uh_tcp_recv(cl, buf, len); 
    154  
    155         /* store received data in peek buffer */ 
    156         if( sz > 0 ) 
    157         { 
    158                 cl->peeklen = sz; 
    159                 memcpy(cl->peekbuf, buf, sz); 
    160         } 
    161  
    162         return sz; 
    163 } 
    164  
    165 int uh_tcp_recv(struct client *cl, char *buf, int len) 
    166 { 
    167         int sz = 0; 
    168         int rsz = 0; 
    169  
    170         fd_set reader; 
    171         struct timeval timeout; 
    172  
    173         /* first serve data from peek buffer */ 
    174         if( cl->peeklen > 0 ) 
    175         { 
    176                 sz = min(cl->peeklen, len); 
    177                 len -= sz; cl->peeklen -= sz; 
    178  
    179                 memcpy(buf, cl->peekbuf, sz); 
    180                 memmove(cl->peekbuf, &cl->peekbuf[sz], cl->peeklen); 
    181         } 
    182  
    183         /* caller wants more */ 
    184         if( len > 0 ) 
    185         { 
    186                 FD_ZERO(&reader); 
    187                 FD_SET(cl->socket, &reader); 
    188  
    189                 timeout.tv_sec  = cl->server->conf->network_timeout; 
    190                 timeout.tv_usec = 0; 
    191  
    192                 if( select(cl->socket + 1, &reader, NULL, NULL, &timeout) > 0 ) 
    193                 { 
    194 #ifdef HAVE_TLS 
    195                         if( cl->tls ) 
    196                                 rsz = cl->server->conf->tls_recv(cl, (void *)&buf[sz], len); 
    197                         else 
    198 #endif 
    199                                 rsz = recv(cl->socket, (void *)&buf[sz], len, 0); 
    200  
    201                         if( (sz == 0) || (rsz > 0) ) 
    202                                 sz += rsz; 
    203                 } 
    204                 else if( sz == 0 ) 
    205                 { 
    206                         sz = -1; 
    207                 } 
     211                        rsz = uh_tcp_recv_lowlevel(cl, (void *)&buf[sz], len); 
     212 
     213                if (rsz < 0) 
     214                        return rsz; 
     215 
     216                sz += rsz; 
    208217        } 
    209218 
  • branches/backfire/package/uhttpd/src/uhttpd-utils.h

    r23953 r28790  
    6565 
    6666int uh_tcp_send(struct client *cl, const char *buf, int len); 
     67int uh_tcp_send_lowlevel(struct client *cl, const char *buf, int len); 
    6768int uh_tcp_peek(struct client *cl, char *buf, int len); 
    6869int uh_tcp_recv(struct client *cl, char *buf, int len); 
     70int uh_tcp_recv_lowlevel(struct client *cl, char *buf, int len); 
    6971 
    7072int uh_http_sendhf( 
  • branches/backfire/package/uhttpd/src/uhttpd.c

    r27629 r28790  
    513513                                                        /* setup client tls context */ 
    514514                                                        if( conf->tls ) 
    515                                                                 conf->tls_accept(cl); 
     515                                                        { 
     516                                                                if( conf->tls_accept(cl) < 1 ) 
     517                                                                { 
     518                                                                        fprintf(stderr, 
     519                                                                                "tls_accept failed, " 
     520                                                                                "connection dropped\n"); 
     521 
     522                                                                        /* close client socket */ 
     523                                                                        close(new_fd); 
     524 
     525                                                                        /* remove from global client list */ 
     526                                                                        uh_client_remove(new_fd); 
     527 
     528                                                                        continue; 
     529                                                                } 
     530                                                        } 
    516531#endif 
    517532 
  • branches/backfire/package/uhttpd/src/uhttpd.h

    r24953 r28790  
    9999        int (*tls_key) (SSL_CTX *c, const char *file); 
    100100        void (*tls_free) (struct listener *l); 
    101         void (*tls_accept) (struct client *c); 
     101        int (*tls_accept) (struct client *c); 
    102102        void (*tls_close) (struct client *c); 
    103103        int (*tls_recv) (struct client *c, void *buf, int len); 
     
    160160 
    161161#endif 
    162  
Note: See TracChangeset for help on using the changeset viewer.