Ignore:
Timestamp:
Sep 23, 2008, 7:11:04 PM (13 years ago)
Author:
charles
Message:

run libT, cli, daemon, gtk through the source-code formatter "uncrustify" as promised/threatened

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/rpc-server.c

    r6703 r6795  
    44 * This file is licensed by the GPL version 2.  Works owned by the
    55 * Transmission project are granted a special exemption to clause 2(b)
    6  * so that the bulk of its code can remain under the MIT license. 
     6 * so that the bulk of its code can remain under the MIT license.
    77 * This exemption does not extend to derived works not owned by
    88 * the Transmission project.
     
    3939struct tr_rpc_server
    4040{
    41     unsigned int isEnabled          : 1;
    42     unsigned int isPasswordEnabled : 1;
    43     int port;
    44     time_t lastRequestTime;
    45     struct shttpd_ctx * ctx;
    46     tr_handle * session;
    47     struct event timer;
    48     char * username;
    49     char * password;
    50     char * acl;
    51     tr_list * connections;
     41    unsigned int         isEnabled         : 1;
     42    unsigned int         isPasswordEnabled : 1;
     43    int                  port;
     44    time_t               lastRequestTime;
     45    struct shttpd_ctx *  ctx;
     46    tr_handle *          session;
     47    struct event         timer;
     48    char *               username;
     49    char *               password;
     50    char *               acl;
     51    tr_list *            connections;
    5252};
    5353
    54 #define dbgmsg(fmt...) tr_deepLog(__FILE__, __LINE__, MY_NAME, ##fmt )
     54#define dbgmsg( fmt... ) tr_deepLog( __FILE__, __LINE__, MY_NAME, ## fmt )
    5555
    5656static const char*
    57 tr_memmem( const char * s1, size_t l1,
    58            const char * s2, size_t l2 )
    59 {
    60     if (!l2) return s1;
    61     while (l1 >= l2) {
     57tr_memmem( const char * s1,
     58           size_t       l1,
     59           const char * s2,
     60           size_t       l2 )
     61{
     62    if( !l2 ) return s1;
     63    while( l1 >= l2 )
     64    {
    6265        l1--;
    63         if (!memcmp(s1,s2,l2))
     66        if( !memcmp( s1, s2, l2 ) )
    6467            return s1;
    6568        s1++;
    6669    }
     70
    6771    return NULL;
    6872}
     
    7478struct ConnBuf
    7579{
    76     char * key;
    77     time_t lastActivity;
    78     struct evbuffer * in;
    79     struct evbuffer * out;
     80    char *             key;
     81    time_t             lastActivity;
     82    struct evbuffer *  in;
     83    struct evbuffer *  out;
    8084};
    8185
     
    8488{
    8589    return tr_strdup_printf( "%s %s",
    86                              shttpd_get_env( arg, "REMOTE_ADDR" ),
    87                              shttpd_get_env( arg, "REQUEST_URI" ) );
     90                            shttpd_get_env( arg, "REMOTE_ADDR" ),
     91                            shttpd_get_env( arg, "REQUEST_URI" ) );
    8892}
    8993
    9094static struct ConnBuf*
    91 getBuffer( tr_rpc_server * server, struct shttpd_arg * arg )
    92 {
    93     tr_list * l;
    94     char * key = buildKey( arg );
     95getBuffer(
     96                        tr_rpc_server * server,
     97    struct shttpd_arg * arg )
     98{
     99    tr_list *        l;
     100    char *           key = buildKey( arg );
    95101    struct ConnBuf * found = NULL;
    96102
    97     for( l=server->connections; l && !found; l=l->next )
     103    for( l = server->connections; l && !found; l = l->next )
    98104    {
    99105        struct ConnBuf * buf = l->data;
     
    117123
    118124static void
    119 pruneBuf( tr_rpc_server * server, struct ConnBuf * buf )
     125pruneBuf( tr_rpc_server *  server,
     126          struct ConnBuf * buf )
    120127{
    121128    tr_list_remove_data( &server->connections, buf );
     
    135142{
    136143    struct tr_rpc_server * s;
    137     struct ConnBuf * cbuf;
     144    struct ConnBuf *       cbuf;
    138145
    139146    s = arg->user_data;
     
    148155        const char * delim;
    149156        const char * in;
    150         size_t inlen;
    151         char * boundary;
    152         size_t boundary_len;
    153         char buf[64];
    154         int paused;
     157        size_t       inlen;
     158        char *       boundary;
     159        size_t       boundary_len;
     160        char         buf[64];
     161        int          paused;
    155162
    156163        /* if we haven't finished reading the POST, read more now */
     
    164171        in = (const char *) EVBUFFER_DATA( cbuf->in );
    165172        inlen = EVBUFFER_LENGTH( cbuf->in );
    166         boundary = tr_strdup_printf( "--%s", strstr( content_type, "boundary=" ) + strlen( "boundary=" ) );
     173        boundary =
     174            tr_strdup_printf( "--%s", strstr( content_type,
     175                                              "boundary=" ) +
     176                             strlen( "boundary=" ) );
    167177        boundary_len = strlen( boundary );
    168178        paused = ( query_string != NULL )
    169               && ( shttpd_get_var( "paused", query_string, strlen( query_string ), buf, sizeof( buf ) ) == 4 )
    170               && ( !strcmp( buf, "true" ) );
     179                 && ( shttpd_get_var( "paused", query_string,
     180                                     strlen( query_string ), buf,
     181                                     sizeof( buf ) ) == 4 )
     182                 && ( !strcmp( buf, "true" ) );
    171183
    172184        delim = tr_memmem( in, inlen, boundary, boundary_len );
    173185        if( delim ) do
    174         {
    175             size_t part_len;
    176             const char * part = delim + boundary_len;
    177             inlen -= ( part - in );
    178             in = part;
    179             delim = tr_memmem( in, inlen, boundary, boundary_len );
    180             part_len = delim ? (size_t)(delim-part) : inlen;
    181 
    182             if( part_len )
    183186            {
    184                 char * text = tr_strndup( part, part_len );
    185                 if( strstr( text, "filename=\"" ) )
     187                size_t       part_len;
     188                const char * part = delim + boundary_len;
     189                inlen -= ( part - in );
     190                in = part;
     191                delim = tr_memmem( in, inlen, boundary, boundary_len );
     192                part_len = delim ? (size_t)( delim - part ) : inlen;
     193
     194                if( part_len )
    186195                {
    187                     const char * body = strstr( text, "\r\n\r\n" );
    188                     if( body )
     196                    char * text = tr_strndup( part, part_len );
     197                    if( strstr( text, "filename=\"" ) )
    189198                    {
    190                         char * b64, *json, *freeme;
    191                         int json_len;
    192                         size_t body_len;
    193                         tr_benc top, *args;
    194 
    195                         body += 4;
    196                         body_len = part_len - ( body - text );
    197                         if( body_len >= 2 && !memcmp(&body[body_len-2],"\r\n",2) )
    198                             body_len -= 2;
    199 
    200                         tr_bencInitDict( &top, 2 );
    201                         args = tr_bencDictAddDict( &top, "arguments", 2 );
    202                         tr_bencDictAddStr( &top, "method", "torrent-add" );
    203                         b64 = tr_base64_encode( body, body_len, NULL );
    204                         tr_bencDictAddStr( args, "metainfo", b64 );
    205                         tr_bencDictAddInt( args, "paused", paused );
    206                         json = tr_bencSaveAsJSON( &top, &json_len );
    207                         freeme = tr_rpc_request_exec_json( s->session, json, json_len, NULL );
    208 
    209                         tr_free( freeme );
    210                         tr_free( json );
    211                         tr_free( b64 );
    212                         tr_bencFree( &top );
     199                        const char * body = strstr( text, "\r\n\r\n" );
     200                        if( body )
     201                        {
     202                            char *  b64, *json, *freeme;
     203                            int     json_len;
     204                            size_t  body_len;
     205                            tr_benc top, *args;
     206
     207                            body += 4;
     208                            body_len = part_len - ( body - text );
     209                            if( body_len >= 2
     210                              && !memcmp( &body[body_len - 2], "\r\n", 2 ) )
     211                                body_len -= 2;
     212
     213                            tr_bencInitDict( &top, 2 );
     214                            args = tr_bencDictAddDict( &top, "arguments", 2 );
     215                            tr_bencDictAddStr( &top, "method",
     216                                               "torrent-add" );
     217                            b64 = tr_base64_encode( body, body_len, NULL );
     218                            tr_bencDictAddStr( args, "metainfo", b64 );
     219                            tr_bencDictAddInt( args, "paused", paused );
     220                            json = tr_bencSaveAsJSON( &top, &json_len );
     221                            freeme =
     222                                tr_rpc_request_exec_json( s->session, json,
     223                                                          json_len,
     224                                                          NULL );
     225
     226                            tr_free( freeme );
     227                            tr_free( json );
     228                            tr_free( b64 );
     229                            tr_bencFree( &top );
     230                        }
    213231                    }
     232                    tr_free( text );
    214233                }
    215                 tr_free( text );
    216234            }
    217         }
    218         while( delim );
     235            while( delim );
    219236
    220237        evbuffer_drain( cbuf->in, EVBUFFER_LENGTH( cbuf->in ) );
     
    225242             * see http://www.malsup.com/jquery/form/#sample7 for details */
    226243            const char * response = "<result>success</result>";
    227             const int len = strlen( response );
    228             evbuffer_add_printf( cbuf->out, "HTTP/1.1 200 OK\r\n"
    229                                             "Content-Type: text/xml; charset=UTF-8\r\n"
    230                                             "Content-Length: %d\r\n"
    231                                             "\r\n"
    232                                            "%s\r\n", len, response );
     244            const int    len = strlen( response );
     245            evbuffer_add_printf(
     246                cbuf->out, "HTTP/1.1 200 OK\r\n"
     247                           "Content-Type: text/xml; charset=UTF-8\r\n"
     248                           "Content-Length: %d\r\n"
     249                           "\r\n"
     250                           "%s\r\n", len, response );
    233251        }
    234252    }
     
    236254    if( EVBUFFER_LENGTH( cbuf->out ) )
    237255    {
    238         const int n = MIN( ( int )EVBUFFER_LENGTH( cbuf->out ), arg->out.len );
     256        const int n = MIN( ( int )EVBUFFER_LENGTH(
     257                              cbuf->out ), arg->out.len );
    239258        memcpy( arg->out.buf, EVBUFFER_DATA( cbuf->out ), n );
    240259        evbuffer_drain( cbuf->out, n );
     
    252271handle_root( struct shttpd_arg * arg )
    253272{
    254     const char * redirect = "HTTP/1.1 200 OK""\r\n"
    255                             "Content-Type: text/html; charset=UTF-8" "\r\n"
    256                             "\r\n"
    257                             "<html><head>" "\r\n"
    258                             "  <meta http-equiv=\"Refresh\" content=\"2; url=/transmission/web/\">" "\r\n"
    259                             "</head><body>" "\r\n"
    260                             "  <p>redirecting to <a href=\"/transmission/web\">/transmission/web/</a></p>" "\r\n"
    261                             "</body></html>" "\r\n";
     273    const char * redirect = "HTTP/1.1 200 OK" "\r\n"
     274                                              "Content-Type: text/html; charset=UTF-8"
     275                                              "\r\n"
     276                                              "\r\n"
     277                                              "<html><head>"
     278                                              "\r\n"
     279                                              "  <meta http-equiv=\"Refresh\" content=\"2; url=/transmission/web/\">"
     280                                              "\r\n"
     281                                              "</head><body>"
     282                                              "\r\n"
     283                                              "  <p>redirecting to <a href=\"/transmission/web\">/transmission/web/</a></p>"
     284                                              "\r\n"
     285                                              "</body></html>"
     286                                              "\r\n";
    262287    const size_t n = strlen( redirect );
     288
    263289    memcpy( arg->out.buf, redirect, n );
    264290    arg->in.num_bytes = arg->in.len;
     
    271297{
    272298    struct tr_rpc_server * s;
    273     struct ConnBuf * cbuf;
     299    struct ConnBuf *       cbuf;
    274300
    275301    s = arg->user_data;
     
    279305    if( !EVBUFFER_LENGTH( cbuf->out ) )
    280306    {
    281         int len = 0;
    282         char * response = NULL;
     307        int          len = 0;
     308        char *       response = NULL;
    283309        const char * request_method = shttpd_get_env( arg, "REQUEST_METHOD" );
    284310        const char * query_string = shttpd_get_env( arg, "QUERY_STRING" );
     
    302328        }
    303329
    304         evbuffer_add_printf( cbuf->out, "HTTP/1.1 200 OK\r\n"
    305                                         "Content-Type: application/json; charset=UTF-8\r\n"
    306                                         "Content-Length: %d\r\n"
    307                                         "\r\n"
    308                                         "%*.*s", len, len, len, response );
     330        evbuffer_add_printf(
     331            cbuf->out, "HTTP/1.1 200 OK\r\n"
     332                       "Content-Type: application/json; charset=UTF-8\r\n"
     333                       "Content-Length: %d\r\n"
     334                       "\r\n"
     335                       "%*.*s", len, len, len, response );
    309336        tr_free( response );
    310337    }
     
    312339    if( EVBUFFER_LENGTH( cbuf->out ) )
    313340    {
    314         const int n = MIN( ( int )EVBUFFER_LENGTH( cbuf->out ), arg->out.len );
     341        const int n = MIN( ( int )EVBUFFER_LENGTH(
     342                              cbuf->out ), arg->out.len );
    315343        memcpy( arg->out.buf, EVBUFFER_DATA( cbuf->out ), n );
    316344        evbuffer_drain( cbuf->out, n );
     
    326354
    327355static void
    328 rpcPulse( int socket UNUSED, short action UNUSED, void * vserver )
    329 {
    330     int interval;
    331     struct timeval tv;
     356rpcPulse( int socket   UNUSED,
     357          short action UNUSED,
     358          void *       vserver )
     359{
     360    int             interval;
     361    struct timeval  tv;
    332362    tr_rpc_server * server = vserver;
    333     const time_t now = time( NULL );
     363    const time_t    now = time( NULL );
    334364
    335365    assert( server );
     
    348378
    349379static void
    350 getPasswordFile( tr_rpc_server * server, char * buf, int buflen )
     380getPasswordFile( tr_rpc_server * server,
     381                 char *          buf,
     382                 int             buflen )
    351383{
    352384    tr_buildPath( buf, buflen, tr_sessionGetConfigDir( server->session ),
    353                                "htpasswd",
    354                                NULL );
     385                  "htpasswd",
     386                  NULL );
    355387}
    356388
     
    362394    if( !server->ctx )
    363395    {
    364         int i;
    365         int argc = 0;
    366         char * argv[100];
    367         char passwd[MAX_PATH_LENGTH];
    368         const char * clutchDir = tr_getClutchDir( server->session );
     396        int            i;
     397        int            argc = 0;
     398        char *         argv[100];
     399        char           passwd[MAX_PATH_LENGTH];
     400        const char *   clutchDir = tr_getClutchDir( server->session );
    369401        struct timeval tv = tr_timevalMsec( INACTIVE_INTERVAL_MSEC );
    370402
     
    373405            unlink( passwd );
    374406        else
    375             shttpd_edit_passwords( passwd, MY_REALM, server->username, server->password );
     407            shttpd_edit_passwords( passwd, MY_REALM, server->username,
     408                                   server->password );
    376409
    377410        argv[argc++] = tr_strdup( "appname-unused" );
     
    401434        if( clutchDir && *clutchDir )
    402435        {
    403             tr_inf( _( "Serving the web interface files from \"%s\"" ), clutchDir );
     436            tr_inf( _(
     437                        "Serving the web interface files from \"%s\"" ),
     438                    clutchDir );
    404439            argv[argc++] = tr_strdup( "-aliases" );
    405440            argv[argc++] = tr_strdup_printf( "%s=%s,%s=%s",
    406                                              "/transmission/clutch", clutchDir,
    407                                              "/transmission/web", clutchDir );
     441                                             "/transmission/clutch",
     442                                             clutchDir,
     443                                             "/transmission/web",
     444                                             clutchDir );
    408445        }
    409446
    410447        argv[argc] = NULL; /* shttpd_init() wants it null-terminated */
    411448
    412         if(( server->ctx = shttpd_init( argc, argv )))
     449        if( ( server->ctx = shttpd_init( argc, argv ) ) )
    413450        {
    414             shttpd_register_uri( server->ctx, "/transmission/rpc", handle_rpc, server );
    415             shttpd_register_uri( server->ctx, "/transmission/upload", handle_upload, server );
     451            shttpd_register_uri( server->ctx, "/transmission/rpc",
     452                                 handle_rpc,
     453                                 server );
     454            shttpd_register_uri( server->ctx, "/transmission/upload",
     455                                 handle_upload,
     456                                 server );
    416457            shttpd_register_uri( server->ctx, "/", handle_root, server );
    417458
     
    420461        }
    421462
    422         for( i=0; i<argc; ++i )
     463        for( i = 0; i < argc; ++i )
    423464            tr_free( argv[i] );
    424465    }
     
    441482
    442483void
    443 tr_rpcSetEnabled( tr_rpc_server * server, int isEnabled )
     484tr_rpcSetEnabled( tr_rpc_server * server,
     485                  int             isEnabled )
    444486{
    445487    server->isEnabled = isEnabled != 0;
     
    458500
    459501void
    460 tr_rpcSetPort( tr_rpc_server * server, int port )
     502tr_rpcSetPort( tr_rpc_server * server,
     503               int             port )
    461504{
    462505    if( server->port != port )
     
    491534 */
    492535
    493 #define FOR_EACH_WORD_IN_LIST(s,len)                                    \
    494         for (; s != NULL && (len = strcspn(s, DELIM_CHARS)) != 0;       \
    495                         s += len, s+= strspn(s, DELIM_CHARS))
    496 
    497 static int isbyte(int n) { return (n >= 0 && n <= 255); }
     536#define FOR_EACH_WORD_IN_LIST( s, len )                                    \
     537    for( ; s != NULL && ( len = strcspn( s, DELIM_CHARS ) ) != 0;       \
     538                         s += len, s += strspn( s, DELIM_CHARS ) )
     539
     540static int
     541isbyte( int n ) { return n >= 0 && n <= 255;  }
    498542
    499543static char*
     
    502546    int len;
    503547
    504     FOR_EACH_WORD_IN_LIST(s, len)
    505     {
    506 
     548    FOR_EACH_WORD_IN_LIST( s, len )
     549    {
    507550        char flag;
    508551        int  a, b, c, d, n, mask;
    509552
    510         if( sscanf(s, "%c%d.%d.%d.%d%n",&flag,&a,&b,&c,&d,&n) != 5 )
    511             return tr_strdup_printf( _( "[%s]: subnet must be [+|-]x.x.x.x[/x]" ), s );
    512         if( flag != '+' && flag != '-')
     553        if( sscanf( s, "%c%d.%d.%d.%d%n", &flag, &a, &b, &c, &d, &n ) != 5 )
     554            return tr_strdup_printf( _(
     555                                         "[%s]: subnet must be [+|-]x.x.x.x[/x]" ),
     556                                     s );
     557        if( flag != '+' && flag != '-' )
    513558            return tr_strdup_printf( _( "[%s]: flag must be + or -" ), s );
    514         if( !isbyte(a) || !isbyte(b) || !isbyte(c) || !isbyte(d) )
     559        if( !isbyte( a ) || !isbyte( b ) || !isbyte( c ) || !isbyte( d ) )
    515560            return tr_strdup_printf( _( "[%s]: bad ip address" ), s );
    516         if( sscanf(s + n, "/%d", &mask) == 1 && ( mask<0 || mask>32 ) )
     561        if( sscanf( s + n, "/%d", &mask ) == 1 && ( mask < 0 || mask > 32 ) )
    517562            return tr_strdup_printf( _( "[%s]: bad subnet mask %d" ), s, n );
    518563    }
     
    526571   192.64.1.2 --> 192.64.1.2/32 */
    527572static void
    528 cidrizeOne( const char * in, int len, struct evbuffer * out )
    529 {
    530     int stars = 0;
     573cidrizeOne( const char *      in,
     574            int               len,
     575            struct evbuffer * out )
     576{
     577    int          stars = 0;
    531578    const char * pch;
    532579    const char * end;
    533     char zero = '0';
    534     char huh = '?';
    535 
    536     for( pch=in, end=pch+len; pch!=end; ++pch ) {
    537         if( stars && isdigit(*pch) )
    538             evbuffer_add( out, &huh, 1 );
    539         else if( *pch!='*' )
     580    char         zero = '0';
     581    char         huh = '?';
     582
     583    for( pch = in, end = pch + len; pch != end; ++pch )
     584    {
     585        if( stars && isdigit( *pch ) )
     586            evbuffer_add( out, &huh, 1 );
     587        else if( *pch != '*' )
    540588            evbuffer_add( out, pch, 1 );
    541         else {
     589        else
     590        {
    542591            evbuffer_add( out, &zero, 1 );
    543592            ++stars;
     
    545594    }
    546595
    547     evbuffer_add_printf( out, "/%d", (32-(stars*8)));
     596    evbuffer_add_printf( out, "/%d", ( 32 - ( stars * 8 ) ) );
    548597}
    549598
     
    551600cidrize( const char * acl )
    552601{
    553     int len;
    554     const char * walk = acl;
    555     char * ret;
     602    int               len;
     603    const char *      walk = acl;
     604    char *            ret;
    556605    struct evbuffer * out = evbuffer_new( );
    557606
     
    570619int
    571620tr_rpcTestACL( const tr_rpc_server  * server UNUSED,
    572                const char           * acl,
    573                char                ** setme_errmsg )
    574 {
    575     int err = 0;
     621               const char *                  acl,
     622               char **                      setme_errmsg )
     623{
     624    int    err = 0;
    576625    char * cidr = cidrize( acl );
    577626    char * errmsg = testACL( cidr );
     627
    578628    if( errmsg )
    579629    {
     
    589639
    590640int
    591 tr_rpcSetACL( tr_rpc_server   * server,
    592               const char      * acl,
    593               char           ** setme_errmsg )
    594 {
    595     char * cidr = cidrize( acl );
     641tr_rpcSetACL( tr_rpc_server * server,
     642              const char *    acl,
     643              char **        setme_errmsg )
     644{
     645    char *    cidr = cidrize( acl );
    596646    const int err = tr_rpcTestACL( server, cidr, setme_errmsg );
    597647
     
    626676
    627677void
    628 tr_rpcSetUsername( tr_rpc_server        * server,
    629                    const char           * username )
     678tr_rpcSetUsername( tr_rpc_server * server,
     679                   const char *    username )
    630680{
    631681    const int isEnabled = server->isEnabled;
     
    643693
    644694char*
    645 tr_rpcGetUsername( const tr_rpc_server  * server )
     695tr_rpcGetUsername( const tr_rpc_server * server )
    646696{
    647697    return tr_strdup( server->username ? server->username : "" );
     
    649699
    650700void
    651 tr_rpcSetPassword( tr_rpc_server        * server,
    652                    const char           * password )
     701tr_rpcSetPassword( tr_rpc_server * server,
     702                   const char *    password )
    653703{
    654704    const int isEnabled = server->isEnabled;
     
    666716
    667717char*
    668 tr_rpcGetPassword( const tr_rpc_server  * server )
     718tr_rpcGetPassword( const tr_rpc_server * server )
    669719{
    670720    return tr_strdup( server->password ? server->password : "" );
     
    672722
    673723void
    674 tr_rpcSetPasswordEnabled( tr_rpc_server  * server,
    675                           int              isEnabled )
     724tr_rpcSetPasswordEnabled( tr_rpc_server * server,
     725                          int             isEnabled )
    676726{
    677727    const int wasEnabled = server->isEnabled;
     
    701751{
    702752    tr_rpc_server * s = *ps;
     753
    703754    *ps = NULL;
    704755
     
    711762
    712763tr_rpc_server *
    713 tr_rpcInit( tr_handle   * session,
    714             int           isEnabled,
    715             int           port,
    716             const char  * acl,
    717             int           isPasswordEnabled,
    718             const char  * username,
    719             const char  * password )
    720 {
    721     char * errmsg;
     764tr_rpcInit( tr_handle * session,
     765            int          isEnabled,
     766            int          port,
     767            const char * acl,
     768            int          isPasswordEnabled,
     769            const char * username,
     770            const char * password )
     771{
     772    char *          errmsg;
    722773    tr_rpc_server * s;
    723774
    724     if(( errmsg = testACL ( acl )))
     775    if( ( errmsg = testACL ( acl ) ) )
    725776    {
    726777        tr_nerr( MY_NAME, errmsg );
     
    738789    s->isPasswordEnabled = isPasswordEnabled != 0;
    739790    s->isEnabled = isEnabled != 0;
    740    
     791
    741792    if( isEnabled )
    742793        startServer( s );
    743     return s;   
    744 }
     794    return s;
     795}
     796
Note: See TracChangeset for help on using the changeset viewer.