Ignore:
Timestamp:
Sep 30, 2007, 1:42:50 AM (13 years ago)
Author:
Paul Smedley
Message:

Update trunk to 3.2.0pre1

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/samba/source/smbd/lanman.c

    r39 r77  
    1010   This program is free software; you can redistribute it and/or modify
    1111   it under the terms of the GNU General Public License as published by
    12    the Free Software Foundation; either version 2 of the License, or
     12   the Free Software Foundation; either version 3 of the License, or
    1313   (at your option) any later version.
    1414   
     
    1919   
    2020   You should have received a copy of the GNU General Public License
    21    along with this program; if not, write to the Free Software
    22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
     21   along with this program.  If not, see <http://www.gnu.org/licenses/>.
    2322   */
    2423/*
     
    5150
    5251#define SHPWLEN 8               /* share password length */
     52
     53/* Limit size of ipc replies */
     54
     55static char *smb_realloc_limit(void *ptr, size_t size)
     56{
     57        char *val;
     58
     59        size = MAX((size),4*1024);
     60        val = (char *)SMB_REALLOC(ptr,size);
     61        if (val) {
     62                memset(val,'\0',size);
     63        }
     64        return val;
     65}
    5366
    5467static BOOL api_Unsupported(connection_struct *conn, uint16 vuid,
     
    118131static char *Expand(connection_struct *conn, int snum, char *s)
    119132{
    120         static pstring buf;
     133        pstring buf;
    121134        if (!s) {
    122135                return NULL;
     
    124137        StrnCpy(buf,s,sizeof(buf)/2);
    125138        pstring_sub(buf,"%S",lp_servicename(snum));
    126         standard_sub_advanced(lp_servicename(SNUM(conn)), conn->user,
    127                               conn->connectpath, conn->gid,
    128                               get_current_username(),
    129                               current_user_info.domain,
    130                               buf, sizeof(buf));
    131         return &buf[0];
     139        return talloc_sub_advanced(talloc_tos(), lp_servicename(SNUM(conn)),
     140                                   conn->user, conn->connectpath, conn->gid,
     141                                   get_current_username(),
     142                                   current_user_info.domain, buf);
    132143}
    133144
     
    405416        SIVAL(drivdata,4,1000); /* lVersion */
    406417        memset(drivdata+8,0,32);        /* szDeviceName */
    407         push_ascii(drivdata+8,"NULL",-1, STR_TERMINATE);
     418        push_ascii(drivdata+8,"NULL",32, STR_TERMINATE);
    408419        PACKl(desc,"l",drivdata,sizeof drivdata); /* pDriverData */
    409420}
     
    828839                *rdata_len = 0;
    829840                *rparam_len = 6;
    830                 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     841                *rparam = smb_realloc_limit(*rparam,*rparam_len);
    831842                if (!*rparam) {
    832843                        return False;
     
    850861
    851862        if (mdrcnt > 0) {
    852                 *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
     863                *rdata = smb_realloc_limit(*rdata,mdrcnt);
    853864                if (!*rdata) {
     865                        SAFE_FREE(queue);
    854866                        return False;
    855867                }
     
    882894        *rdata_len = desc.usedlen;
    883895        *rparam_len = 6;
    884         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     896        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    885897        if (!*rparam) {
     898                SAFE_FREE(queue);
     899                SAFE_FREE(tmpdata);
    886900                return False;
    887901        }
     
    941955                *rdata_len = 0;
    942956                *rparam_len = 6;
    943                 *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     957                *rparam = smb_realloc_limit(*rparam,*rparam_len);
    944958                if (!*rparam) {
    945959                        return False;
     
    983997
    984998        if (mdrcnt > 0) {
    985                 *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
     999                *rdata = smb_realloc_limit(*rdata,mdrcnt);
    9861000                if (!*rdata) {
    9871001                        goto err;
     
    10091023        *rdata_len = desc.usedlen;
    10101024        *rparam_len = 8;
    1011         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     1025        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    10121026        if (!*rparam) {
    10131027                goto err;
     
    13821396
    13831397        *rdata_len = fixed_len + string_len;
    1384         *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
     1398        *rdata = smb_realloc_limit(*rdata,*rdata_len);
    13851399        if (!*rdata) {
    13861400                return False;
    13871401        }
    1388         memset(*rdata,'\0',*rdata_len);
    13891402 
    13901403        p2 = (*rdata) + fixed_len;      /* auxilliary data (strings) will go here */
     
    14121425 
    14131426        *rparam_len = 8;
    1414         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     1427        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    14151428        if (!*rparam) {
    14161429                return False;
     
    14611474 
    14621475        *rparam_len = 8;
    1463         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     1476        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    14641477        if (!*rparam) {
    14651478                return False;
     
    16531666        }
    16541667 
    1655         *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
     1668        *rdata = smb_realloc_limit(*rdata,mdrcnt);
    16561669        if (!*rdata) {
    16571670                return False;
     
    16641677 
    16651678        *rparam_len = 6;
    1666         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     1679        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    16671680        if (!*rparam) {
    16681681                return False;
     
    17211734        /* Ensure all the usershares are loaded. */
    17221735        become_root();
     1736        load_registry_shares();
    17231737        count = load_usershare_shares();
    17241738        unbecome_root();
     
    17461760
    17471761        *rdata_len = fixed_len + string_len;
    1748         *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
     1762        *rdata = smb_realloc_limit(*rdata,*rdata_len);
    17491763        if (!*rdata) {
    17501764                return False;
    17511765        }
    1752         memset(*rdata,0,*rdata_len);
    1753  
     1766 
    17541767        p2 = (*rdata) + fixed_len;      /* auxiliary data (strings) will go here */
    17551768        p = *rdata;
     
    17721785 
    17731786        *rparam_len = 8;
    1774         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     1787        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    17751788        if (!*rparam) {
    17761789                return False;
     
    18941907                } else {
    18951908                        SAFE_FREE(command);
    1896                         message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
     1909                        message_send_all(smbd_messaging_context(),
     1910                                         MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
    18971911                }
    18981912        } else {
     
    19011915
    19021916        *rparam_len = 6;
    1903         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     1917        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    19041918        if (!*rparam) {
    19051919                return False;
     
    19151929
    19161930        *rparam_len = 4;
    1917         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     1931        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    19181932        if (!*rparam) {
    19191933                return False;
     
    19892003
    19902004        *rdata_len = cli_buf_size;
    1991         *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
     2005        *rdata = smb_realloc_limit(*rdata,*rdata_len);
    19922006        if (!*rdata) {
    19932007                return False;
     
    20192033
    20202034        *rparam_len = 8;
    2021         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     2035        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    20222036        if (!*rparam) {
    20232037                return False;
     
    20652079
    20662080        *rparam_len = 8;
    2067         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     2081        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    20682082        if (!*rparam) {
    20692083                return False;
    20702084        }
    2071  
     2085
    20722086        /* check it's a supported varient */
    2073        
     2087
    20742088        if ( strcmp(str1,"zWrLeh") != 0 )
    20752089                return False;
    2076                
     2090
    20772091        switch( uLevel ) {
    20782092                case 0:
     
    20872101
    20882102        *rdata_len = mdrcnt + 1024;
    2089         *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
     2103        *rdata = smb_realloc_limit(*rdata,*rdata_len);
    20902104        if (!*rdata) {
    20912105                return False;
    20922106        }
     2107
    20932108        SSVAL(*rparam,0,NERR_Success);
    20942109        SSVAL(*rparam,2,0);             /* converter word */
     
    22122227
    22132228        *rparam_len = 8;
    2214         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     2229        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    22152230        if (!*rparam) {
    22162231                return False;
     
    22222237
    22232238        *rdata_len = cli_buf_size;
    2224         *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
     2239        *rdata = smb_realloc_limit(*rdata,*rdata_len);
    22252240        if (!*rdata) {
    22262241                return False;
     
    22902305
    22912306        *rparam_len = 4;
    2292         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     2307        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    22932308        if (!*rparam) {
    22942309                return False;
     
    22962311
    22972312        *rdata_len = 21;
    2298         *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
     2313        *rdata = smb_realloc_limit(*rdata,*rdata_len);
    22992314        if (!*rdata) {
    23002315                return False;
     
    23802395
    23812396        *rparam_len = 4;
    2382         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     2397        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    23832398        if (!*rparam) {
    23842399                return False;
     
    24572472        char *p = get_safe_str_ptr(param,tpscnt,param,2);
    24582473        *rparam_len = 2;
    2459         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     2474        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    24602475        if (!*rparam) {
    24612476                return False;
     
    25602575
    25612576        *rparam_len = 4;
    2562         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);       
     2577        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    25632578        if (!*rparam) {
    25642579                return False;
     
    26322647
    26332648        *rparam_len = 4;
    2634         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     2649        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    26352650        if (!*rparam) {
    26362651                return False;
     
    27302745                return False;
    27312746        *rparam_len = 4;
    2732         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     2747        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    27332748        if (!*rparam) {
    27342749                return False;
     
    28552870
    28562871        *rdata_len = mdrcnt;
    2857         *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
     2872        *rdata = smb_realloc_limit(*rdata,*rdata_len);
    28582873        if (!*rdata) {
    28592874                return False;
     
    28632878        p2 = p + struct_len;
    28642879        if (uLevel != 20) {
    2865                 srvstr_push(NULL, p,global_myname(),16,
     2880                srvstr_push(NULL, 0, p,global_myname(),16,
    28662881                        STR_ASCII|STR_UPPER|STR_TERMINATE);
    28672882        }
     
    29142929
    29152930        *rparam_len = 6;
    2916         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     2931        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    29172932        if (!*rparam) {
    29182933                return False;
     
    29492964
    29502965        *rparam_len = 6;
    2951         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     2966        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    29522967        if (!*rparam) {
    29532968                return False;
     
    29602975
    29612976        *rdata_len = mdrcnt + 1024;
    2962         *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
     2977        *rdata = smb_realloc_limit(*rdata,*rdata_len);
    29632978        if (!*rdata) {
    29642979                return False;
     
    32283243
    32293244        *rparam_len = 6;
    3230         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     3245        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    32313246        if (!*rparam) {
    32323247                return False;
     
    32533268
    32543269        *rdata_len = mdrcnt + 1024;
    3255         *rdata = SMB_REALLOC_LIMIT(*rdata,*rdata_len);
     3270        *rdata = smb_realloc_limit(*rdata,*rdata_len);
    32563271        if (!*rdata) {
    32573272                return False;
     
    34633478        }
    34643479        if (mdrcnt > 0) {
    3465                 *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
     3480                *rdata = smb_realloc_limit(*rdata,mdrcnt);
    34663481                if (!*rdata) {
    34673482                        return False;
     
    35053520        *rdata_len = desc.usedlen;
    35063521        *rparam_len = 6;
    3507         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     3522        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    35083523        if (!*rparam) {
    35093524                return False;
     
    35523567
    35533568        *rparam_len = 6;
    3554         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     3569        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    35553570        if (!*rparam) {
    35563571                return False;
     
    36243639
    36253640        if (mdrcnt > 0) {
    3626                 *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
     3641                *rdata = smb_realloc_limit(*rdata,mdrcnt);
    36273642                if (!*rdata) {
    36283643                        return False;
     
    36503665
    36513666        *rparam_len = 6;
    3652         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     3667        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    36533668        if (!*rparam) {
    36543669                return False;
     
    37203735        count = print_queue_status(snum,&queue,&status);
    37213736        if (mdrcnt > 0) {
    3722                 *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
     3737                *rdata = smb_realloc_limit(*rdata,mdrcnt);
    37233738                if (!*rdata) {
    37243739                        return False;
     
    37413756
    37423757        *rparam_len = 8;
    3743         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     3758        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    37443759        if (!*rparam) {
    37453760                return False;
     
    38683883        } else {
    38693884                if (mdrcnt > 0) {
    3870                         *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
     3885                        *rdata = smb_realloc_limit(*rdata,mdrcnt);
    38713886                        if (!*rdata) {
    38723887                                return False;
     
    38893904
    38903905        *rparam_len = 6;
    3891         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     3906        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    38923907        if (!*rparam) {
    38933908                return False;
     
    39453960
    39463961        if (mdrcnt > 0) {
    3947                 *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
     3962                *rdata = smb_realloc_limit(*rdata,mdrcnt);
    39483963                if (!*rdata) {
    39493964                        return False;
     
    39703985
    39713986        *rparam_len = 8;
    3972         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     3987        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    39733988        if (!*rparam) {
    39743989                return False;
     
    40174032
    40184033        if (mdrcnt > 0) {
    4019                 *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
     4034                *rdata = smb_realloc_limit(*rdata,mdrcnt);
    40204035                if (!*rdata) {
    40214036                        return False;
     
    40334048
    40344049        *rparam_len = 8;
    4035         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     4050        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    40364051        if (!*rparam) {
    40374052                return False;
     
    40794094
    40804095        if (mdrcnt > 0) {
    4081                 *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
     4096                *rdata = smb_realloc_limit(*rdata,mdrcnt);
    40824097                if (!*rdata) {
    40834098                        return False;
     
    40964111
    40974112        *rparam_len = 8;
    4098         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     4113        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    40994114        if (!*rparam) {
    41004115                return False;
     
    41434158
    41444159        if (mdrcnt > 0) {
    4145                 *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
     4160                *rdata = smb_realloc_limit(*rdata,mdrcnt);
    41464161                if (!*rdata) {
    41474162                        return False;
     
    41614176
    41624177        *rparam_len = 8;
    4163         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     4178        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    41644179        if (!*rparam) {
    41654180                return False;
     
    41924207        int uLevel;
    41934208        struct pack_desc desc;
    4194         struct sessionid *session_list = NULL;
     4209        struct sessionid *session_list;
    41954210        int i, num_sessions;
    41964211
     
    42154230        }
    42164231
    4217         num_sessions = list_sessions(&session_list);
     4232        num_sessions = list_sessions(talloc_tos(), &session_list);
    42184233
    42194234        if (mdrcnt > 0) {
    4220                 *rdata = SMB_REALLOC_LIMIT(*rdata,mdrcnt);
     4235                *rdata = smb_realloc_limit(*rdata,mdrcnt);
    42214236                if (!*rdata) {
    4222                         SAFE_FREE(session_list);
    42234237                        return False;
    42244238                }
     
    42294243        desc.format = str2;
    42304244        if (!init_package(&desc,num_sessions,0)) {
    4231                 SAFE_FREE(session_list);
    42324245                return False;
    42334246        }
     
    42484261
    42494262        *rparam_len = 8;
    4250         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     4263        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    42514264        if (!*rparam) {
    4252                 SAFE_FREE(session_list);
    42534265                return False;
    42544266        }
     
    42594271        DEBUG(4,("RNetSessionEnum: errorcode %d\n",desc.errcode));
    42604272
    4261         SAFE_FREE(session_list);
    42624273        return True;
    42634274}
     
    42744285{
    42754286        *rparam_len = MIN(*rparam_len,mprcnt);
    4276         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     4287        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    42774288        if (!*rparam) {
    42784289                return False;
     
    43004311{
    43014312        *rparam_len = 4;
    4302         *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     4313        *rparam = smb_realloc_limit(*rparam,*rparam_len);
    43034314        if (!*rparam) {
    43044315                return False;
     
    43664377
    43674378/****************************************************************************
    4368  Handle remote api calls
    4369  ****************************************************************************/
    4370 
    4371 int api_reply(connection_struct *conn,uint16 vuid,char *outbuf,char *data,char *params,
    4372                      int tdscnt,int tpscnt,int mdrcnt,int mprcnt)
     4379 Handle remote api calls.
     4380****************************************************************************/
     4381
     4382void api_reply(connection_struct *conn, uint16 vuid,
     4383               struct smb_request *req,
     4384               char *data, char *params,
     4385               int tdscnt, int tpscnt,
     4386               int mdrcnt, int mprcnt)
    43734387{
    43744388        int api_command;
     
    43844398        if (!params) {
    43854399                DEBUG(0,("ERROR: NULL params in api_reply()\n"));
    4386                 return 0;
     4400                reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
     4401                return;
    43874402        }
    43884403
    43894404        if (tpscnt < 2) {
    4390                 return 0;
     4405                reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
     4406                return;
    43914407        }
    43924408        api_command = SVAL(params,0);
     
    44214437
    44224438                if (!user || user->guest) {
    4423                         return ERROR_NT(NT_STATUS_ACCESS_DENIED);
     4439                        reply_nterror(req, NT_STATUS_ACCESS_DENIED);
     4440                        return;
    44244441                }
    44254442        }
     
    44394456                SAFE_FREE(rdata);
    44404457                SAFE_FREE(rparam);
    4441                 return -1;
     4458                reply_nterror(req, NT_STATUS_NO_MEMORY);
     4459                return;
    44424460        }
    44434461
     
    44634481        /* If api_Unsupported returns false we can't return anything. */
    44644482        if (reply) {
    4465                 send_trans_reply(outbuf, rparam, rparam_len, rdata, rdata_len, False);
     4483                send_trans_reply(req, rparam, rparam_len,
     4484                                 rdata, rdata_len, False);
    44664485        }
    44674486
    44684487        SAFE_FREE(rdata);
    44694488        SAFE_FREE(rparam);
    4470         return -1;
    4471 }
     4489        return;
     4490}
Note: See TracChangeset for help on using the changeset viewer.