Ignore:
Timestamp:
Apr 10, 2007, 5:27:38 AM (14 years ago)
Author:
Paul Smedley
Message:

Updated source to 3.0.25rc1

File:
1 edited

Legend:

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

    r1 r26  
    33   Inter-process communication and named pipe handling
    44   Copyright (C) Andrew Tridgell 1992-1998
     5   Copyright (C) Jeremy Allison 2007.
    56
    67   SMB Version handling
     
    5152#define SHPWLEN 8               /* share password length */
    5253
    53 static BOOL api_Unsupported(connection_struct *conn,uint16 vuid, char *param, char *data,
    54                             int mdrcnt, int mprcnt,
    55                             char **rdata, char **rparam,
    56                             int *rdata_len, int *rparam_len);
     54static BOOL api_Unsupported(connection_struct *conn, uint16 vuid,
     55                                char *param, int tpscnt,
     56                                char *data, int tdscnt,
     57                                int mdrcnt, int mprcnt,
     58                                char **rdata, char **rparam,
     59                                int *rdata_len, int *rparam_len);
     60
    5761static BOOL api_TooSmall(connection_struct *conn, uint16 vuid, char *param, char *data,
    5862                         int mdrcnt, int mprcnt,
     
    438442                        break;
    439443                default:
     444                        DEBUG(0,("check_printq_info: invalid level %d\n",
     445                                uLevel ));
    440446                        return False;
    441447        }
    442         if (strcmp(desc->format,id1) != 0) {
    443                 return False;
    444         }
    445         if (desc->subformat && strcmp(desc->subformat,id2) != 0) {
     448        if (id1 == NULL || strcmp(desc->format,id1) != 0) {
     449                DEBUG(0,("check_printq_info: invalid format %s\n",
     450                        id1 ? id1 : "<NULL>" ));
     451                return False;
     452        }
     453        if (desc->subformat && (id2 == NULL || strcmp(desc->subformat,id2) != 0)) {
     454                DEBUG(0,("check_printq_info: invalid subformat %s\n",
     455                        id2 ? id2 : "<NULL>" ));
    446456                return False;
    447457        }
     
    586596                goto err;
    587597        }
    588                
     598
    589599        if ( !W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername,
    590600                "Windows 4.0", 0)) )
     
    598608        trim_string(driver.info_3->datafile, "\\print$\\WIN40\\0\\", 0);
    599609        trim_string(driver.info_3->helpfile, "\\print$\\WIN40\\0\\", 0);
    600        
     610
    601611        PACKI(desc, "W", 0x0400);                     /* don't know */
    602612        PACKS(desc, "z", driver.info_3->name);        /* long printer name */
     
    604614        PACKS(desc, "z", driver.info_3->datafile);    /* Datafile name */
    605615        PACKS(desc, "z", driver.info_3->monitorname); /* language monitor */
    606        
     616
    607617        fstrcpy(location, "\\\\%L\\print$\\WIN40\\0");
    608618        standard_sub_basic( "", "", location, sizeof(location)-1 );
    609619        PACKS(desc,"z", location);                          /* share to retrieve files */
    610        
     620
    611621        PACKS(desc,"z", driver.info_3->defaultdatatype);    /* default data type */
    612622        PACKS(desc,"z", driver.info_3->helpfile);           /* helpfile name */
     
    628638                DEBUG(3,("Dependent File: %s:\n",driver.info_3->dependentfiles[i]));
    629639        }
    630        
     640
    631641        /* sanity check */
    632642        if ( i != count )
    633643                DEBUG(3,("fill_printq_info_52: file count specified by client [%d] != number of dependent files [%i]\n",
    634644                        count, i));
    635                
     645
    636646        DEBUG(3,("fill_printq_info on <%s> gave %d entries\n", SERVICE(snum),i));
    637647
     
    646656        if ( printer )
    647657                free_a_printer( &printer, 2 );
    648                
     658
    649659        if ( driver.info_3 )
    650660                free_a_printer_driver( driver, 3 );
     
    744754                goto done;
    745755        }
    746                
     756
    747757        if ( !W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername,
    748758                "Windows 4.0", 0)) )
     
    752762                goto done;
    753763        }
    754        
     764
    755765        /* count the number of files */
    756766        while ( driver.info_3->dependentfiles && *driver.info_3->dependentfiles[result] )
     
    760770        if ( printer )
    761771                free_a_printer( &printer, 2 );
    762                
     772
    763773        if ( driver.info_3 )
    764774                free_a_printer_driver( driver, 3 );
    765                
     775
    766776        return result;
    767777}
    768778
    769 static BOOL api_DosPrintQGetInfo(connection_struct *conn,
    770                                  uint16 vuid, char *param,char *data,
    771                                  int mdrcnt,int mprcnt,
    772                                  char **rdata,char **rparam,
    773                                  int *rdata_len,int *rparam_len)
    774 {
    775         char *str1 = param+2;
    776         char *str2 = skip_string(str1,1);
    777         char *p = skip_string(str2,1);
     779static BOOL api_DosPrintQGetInfo(connection_struct *conn, uint16 vuid,
     780                                char *param, int tpscnt,
     781                                char *data, int tdscnt,
     782                                int mdrcnt,int mprcnt,
     783                                char **rdata,char **rparam,
     784                                int *rdata_len,int *rparam_len)
     785{
     786        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     787        char *str2 = skip_string(param,tpscnt,str1);
     788        char *p = skip_string(param,tpscnt,str2);
    778789        char *QueueName = p;
    779790        unsigned int uLevel;
    780791        int count=0;
    781792        int snum;
    782         char* str3;
     793        char *str3;
    783794        struct pack_desc desc;
    784795        print_queue_struct *queue=NULL;
     
    786797        char* tmpdata=NULL;
    787798
     799        if (!str1 || !str2 || !p) {
     800                return False;
     801        }
    788802        memset((char *)&status,'\0',sizeof(status));
    789803        memset((char *)&desc,'\0',sizeof(desc));
    790  
    791         p = skip_string(p,1);
    792         uLevel = SVAL(p,0);
    793         str3 = p + 4;
    794  
     804
     805        p = skip_string(param,tpscnt,p);
     806        if (!p) {
     807                return False;
     808        }
     809        uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
     810        str3 = get_safe_str_ptr(param,tpscnt,p,4);
     811        /* str3 may be null here and is checked in check_printq_info(). */
     812
    795813        /* remove any trailing username */
    796814        if ((p = strchr_m(QueueName,'%')))
     
    884902****************************************************************************/
    885903
    886 static BOOL api_DosPrintQEnum(connection_struct *conn, uint16 vuid, char* param, char* data,
    887                               int mdrcnt, int mprcnt,
    888                               char **rdata, char** rparam,
    889                               int *rdata_len, int *rparam_len)
    890 {
    891         char *param_format = param+2;
    892         char *output_format1 = skip_string(param_format,1);
    893         char *p = skip_string(output_format1,1);
    894         unsigned int uLevel = SVAL(p,0);
    895         char *output_format2 = p + 4;
     904static BOOL api_DosPrintQEnum(connection_struct *conn, uint16 vuid,
     905                                char *param, int tpscnt,
     906                                char *data, int tdscnt,
     907                                int mdrcnt, int mprcnt,
     908                                char **rdata, char** rparam,
     909                                int *rdata_len, int *rparam_len)
     910{
     911        char *param_format = get_safe_str_ptr(param,tpscnt,param,2);
     912        char *output_format1 = skip_string(param,tpscnt,param_format);
     913        char *p = skip_string(param,tpscnt,output_format1);
     914        unsigned int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
     915        char *output_format2 = get_safe_str_ptr(param,tpscnt,p,4);
    896916        int services = lp_numservices();
    897917        int i, n;
     
    902922        int queuecnt = 0, subcnt = 0, succnt = 0;
    903923 
     924        if (!param_format || !output_format1 || !p) {
     925                return False;
     926        }
     927
    904928        memset((char *)&desc,'\0',sizeof(desc));
    905929
     
    12531277****************************************************************************/
    12541278
    1255 static BOOL api_RNetServerEnum(connection_struct *conn, uint16 vuid, char *param, char *data,
    1256                                int mdrcnt, int mprcnt, char **rdata,
    1257                                char **rparam, int *rdata_len, int *rparam_len)
    1258 {
    1259         char *str1 = param+2;
    1260         char *str2 = skip_string(str1,1);
    1261         char *p = skip_string(str2,1);
    1262         int uLevel = SVAL(p,0);
    1263         int buf_len = SVAL(p,2);
    1264         uint32 servertype = IVAL(p,4);
     1279static BOOL api_RNetServerEnum(connection_struct *conn, uint16 vuid,
     1280                                char *param, int tpscnt,
     1281                                char *data, int tdscnt,
     1282                                int mdrcnt, int mprcnt, char **rdata,
     1283                                char **rparam, int *rdata_len, int *rparam_len)
     1284{
     1285        char *str1 = get_safe_str_ptr(param, tpscnt, param, 2);
     1286        char *str2 = skip_string(param,tpscnt,str1);
     1287        char *p = skip_string(param,tpscnt,str2);
     1288        int uLevel = get_safe_SVAL(param, tpscnt, p, 0, -1);
     1289        int buf_len = get_safe_SVAL(param,tpscnt, p, 2, 0);
     1290        uint32 servertype = get_safe_IVAL(param,tpscnt,p,4, 0);
    12651291        char *p2;
    12661292        int data_len, fixed_len, string_len;
     
    12731299        BOOL local_request;
    12741300
     1301        if (!str1 || !str2 || !p) {
     1302                return False;
     1303        }
     1304
    12751305        /* If someone sets all the bits they don't really mean to set
    12761306           DOMAIN_ENUM and LOCAL_LIST_ONLY, they just want all the
     
    13081338
    13091339        if (strcmp(str1, "WrLehDz") == 0) {
     1340                if (skip_string(param,tpscnt,p) == NULL) {
     1341                        return False;
     1342                }
    13101343                pull_ascii_fstring(domain, p);
    13111344        } else {
     
    14001433  ****************************************************************************/
    14011434
    1402 static BOOL api_RNetGroupGetUsers(connection_struct *conn, uint16 vuid, char *param, char *data,
    1403                                int mdrcnt, int mprcnt, char **rdata,
    1404                                char **rparam, int *rdata_len, int *rparam_len)
    1405 {
    1406         char *str1 = param+2;
    1407         char *str2 = skip_string(str1,1);
    1408         char *p = skip_string(str2,1);
    1409         int uLevel = SVAL(p,0);
    1410         int buf_len = SVAL(p,2);
     1435static BOOL api_RNetGroupGetUsers(connection_struct *conn, uint16 vuid,
     1436                                char *param, int tpscnt,
     1437                                char *data, int tdscnt,
     1438                                int mdrcnt, int mprcnt, char **rdata,
     1439                                char **rparam, int *rdata_len, int *rparam_len)
     1440{
     1441        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     1442        char *str2 = skip_string(param,tpscnt,str1);
     1443        char *p = skip_string(param,tpscnt,str2);
     1444        int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
     1445        int buf_len = get_safe_SVAL(param,tpscnt,p,2,0);
    14111446        int counted=0;
    14121447        int missed=0;
     1448
     1449        if (!str1 || !str2 || !p) {
     1450                return False;
     1451        }
    14131452
    14141453        DEBUG(5,("RNetGroupGetUsers: %s %s %s %d %d\n",
     
    15831622}
    15841623
    1585 static BOOL api_RNetShareGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
    1586                                  int mdrcnt,int mprcnt,
    1587                                  char **rdata,char **rparam,
    1588                                  int *rdata_len,int *rparam_len)
    1589 {
    1590         char *str1 = param+2;
    1591         char *str2 = skip_string(str1,1);
    1592         char *netname = skip_string(str2,1);
    1593         char *p = skip_string(netname,1);
    1594         int uLevel = SVAL(p,0);
    1595         int snum = find_service(netname);
     1624static BOOL api_RNetShareGetInfo(connection_struct *conn,uint16 vuid,
     1625                                char *param, int tpscnt,
     1626                                char *data, int tdscnt,
     1627                                int mdrcnt,int mprcnt,
     1628                                char **rdata,char **rparam,
     1629                                int *rdata_len,int *rparam_len)
     1630{
     1631        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     1632        char *str2 = skip_string(param,tpscnt,str1);
     1633        char *netname = skip_string(param,tpscnt,str2);
     1634        char *p = skip_string(param,tpscnt,netname);
     1635        int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
     1636        int snum;
    15961637 
     1638        if (!str1 || !str2 || !netname || !p) {
     1639                return False;
     1640        }
     1641
     1642        snum = find_service(netname);
    15971643        if (snum < 0) {
    15981644                return False;
     
    16391685 ****************************************************************************/
    16401686
    1641 static BOOL api_RNetShareEnum( connection_struct *conn,
    1642                                uint16             vuid,
    1643                                char              *param,
    1644                                char              *data,
    1645                                int                mdrcnt,
    1646                                int                mprcnt,
    1647                                char             **rdata,
    1648                                char             **rparam,
    1649                                int               *rdata_len,
    1650                                int               *rparam_len )
    1651 {
    1652         char *str1 = param+2;
    1653         char *str2 = skip_string(str1,1);
    1654         char *p = skip_string(str2,1);
    1655         int uLevel = SVAL(p,0);
    1656         int buf_len = SVAL(p,2);
     1687static BOOL api_RNetShareEnum( connection_struct *conn, uint16 vuid,
     1688                                char *param, int tpscnt,
     1689                                char *data, int tdscnt,
     1690                                int                mdrcnt,
     1691                                int                mprcnt,
     1692                                char             **rdata,
     1693                                char             **rparam,
     1694                                int               *rdata_len,
     1695                                int               *rparam_len )
     1696{
     1697        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     1698        char *str2 = skip_string(param,tpscnt,str1);
     1699        char *p = skip_string(param,tpscnt,str2);
     1700        int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
     1701        int buf_len = get_safe_SVAL(param,tpscnt,p,2,0);
    16571702        char *p2;
    16581703        int count = 0;
     
    16631708        int f_len = 0, s_len = 0;
    16641709 
     1710        if (!str1 || !str2 || !p) {
     1711                return False;
     1712        }
     1713
    16651714        if (!prefix_ok(str1,"WrLeh")) {
    16661715                return False;
     
    17431792  ****************************************************************************/
    17441793
    1745 static BOOL api_RNetShareAdd(connection_struct *conn,uint16 vuid, char *param,char *data,
    1746                                  int mdrcnt,int mprcnt,
    1747                                  char **rdata,char **rparam,
    1748                                  int *rdata_len,int *rparam_len)
    1749 {
    1750         char *str1 = param+2;
    1751         char *str2 = skip_string(str1,1);
    1752         char *p = skip_string(str2,1);
    1753         int uLevel = SVAL(p,0);
     1794static BOOL api_RNetShareAdd(connection_struct *conn,uint16 vuid,
     1795                                char *param, int tpscnt,
     1796                                char *data, int tdscnt,
     1797                                int mdrcnt,int mprcnt,
     1798                                char **rdata,char **rparam,
     1799                                int *rdata_len,int *rparam_len)
     1800{
     1801        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     1802        char *str2 = skip_string(param,tpscnt,str1);
     1803        char *p = skip_string(param,tpscnt,str2);
     1804        int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
    17541805        fstring sharename;
    17551806        fstring comment;
     
    17601811        int res = ERRunsup;
    17611812 
     1813        if (!str1 || !str2 || !p) {
     1814                return False;
     1815        }
     1816
    17621817        /* check it's a supported varient */
    17631818        if (!prefix_ok(str1,RAP_WShareAdd_REQ)) {
     
    17711826        }
    17721827
     1828        /* Do we have a string ? */
     1829        if (skip_string(data,mdrcnt,data) == NULL) {
     1830                return False;
     1831        }
    17731832        pull_ascii_fstring(sharename,data);
    17741833        snum = find_service(sharename);
     
    17781837        }
    17791838
     1839        if (mdrcnt < 28) {
     1840                return False;
     1841        }
     1842
    17801843        /* only support disk share adds */
    17811844        if (SVAL(data,14)!=STYPE_DISKTREE) {
     
    17891852        }
    17901853
     1854        /* Do we have a string ? */
     1855        if (skip_string(data,mdrcnt,data+offset) == NULL) {
     1856                return False;
     1857        }
    17911858        pull_ascii_fstring(comment, offset? (data+offset) : "");
    17921859
     
    17981865        }
    17991866
     1867        /* Do we have a string ? */
     1868        if (skip_string(data,mdrcnt,data+offset) == NULL) {
     1869                return False;
     1870        }
    18001871        pull_ascii_pstring(pathname, offset? (data+offset) : "");
    18011872
     
    18581929  ****************************************************************************/
    18591930
    1860 static BOOL api_RNetGroupEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
    1861                               int mdrcnt,int mprcnt,
    1862                               char **rdata,char **rparam,
    1863                               int *rdata_len,int *rparam_len)
     1931static BOOL api_RNetGroupEnum(connection_struct *conn,uint16 vuid,
     1932                                char *param, int tpscnt,
     1933                                char *data, int tdscnt,
     1934                                int mdrcnt,int mprcnt,
     1935                                char **rdata,char **rparam,
     1936                                int *rdata_len,int *rparam_len)
    18641937{
    18651938        int i;
    18661939        int errflags=0;
    18671940        int resume_context, cli_buf_size;
    1868         char *str1 = param+2;
    1869         char *str2 = skip_string(str1,1);
    1870         char *p = skip_string(str2,1);
     1941        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     1942        char *str2 = skip_string(param,tpscnt,str1);
     1943        char *p = skip_string(param,tpscnt,str2);
    18711944
    18721945        struct pdb_search *search;
     
    18751948        int num_entries;
    18761949 
     1950        if (!str1 || !str2 || !p) {
     1951                return False;
     1952        }
     1953
    18771954        if (strcmp(str1,"WrLeh") != 0) {
    18781955                return False;
     
    19011978        }
    19021979
    1903         resume_context = SVAL(p,0);
    1904         cli_buf_size=SVAL(p+2,0);
     1980        resume_context = get_safe_SVAL(param,tpscnt,p,0,-1);
     1981        cli_buf_size= get_safe_SVAL(param,tpscnt,p,2,0);
    19051982        DEBUG(10,("api_RNetGroupEnum:resume context: %d, client buffer size: "
    19061983                  "%d\n", resume_context, cli_buf_size));
     
    19582035******************************************************************/
    19592036
    1960 static BOOL api_NetUserGetGroups(connection_struct *conn,uint16 vuid, char *param,char *data,
    1961                               int mdrcnt,int mprcnt,
    1962                               char **rdata,char **rparam,
    1963                               int *rdata_len,int *rparam_len)
    1964 {
    1965         char *str1 = param+2;
    1966         char *str2 = skip_string(str1,1);
    1967         char *UserName = skip_string(str2,1);
    1968         char *p = skip_string(UserName,1);
    1969         int uLevel = SVAL(p,0);
     2037static BOOL api_NetUserGetGroups(connection_struct *conn,uint16 vuid,
     2038                                char *param, int tpscnt,
     2039                                char *data, int tdscnt,
     2040                                int mdrcnt,int mprcnt,
     2041                                char **rdata,char **rparam,
     2042                                int *rdata_len,int *rparam_len)
     2043{
     2044        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     2045        char *str2 = skip_string(param,tpscnt,str1);
     2046        char *UserName = skip_string(param,tpscnt,str2);
     2047        char *p = skip_string(param,tpscnt,UserName);
     2048        int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
    19702049        const char *level_string;
    19712050        int count=0;
     
    19812060        TALLOC_CTX *mem_ctx;
    19822061
     2062        if (!str1 || !str2 || !UserName || !p) {
     2063                return False;
     2064        }
     2065
    19832066        *rparam_len = 8;
    19842067        *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     
    20912174******************************************************************/
    20922175
    2093 static BOOL api_RNetUserEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
    2094                                  int mdrcnt,int mprcnt,
    2095                                  char **rdata,char **rparam,
    2096                                  int *rdata_len,int *rparam_len)
     2176static BOOL api_RNetUserEnum(connection_struct *conn, uint16 vuid,
     2177                                char *param, int tpscnt,
     2178                                char *data, int tdscnt,
     2179                                int mdrcnt,int mprcnt,
     2180                                char **rdata,char **rparam,
     2181                                int *rdata_len,int *rparam_len)
    20972182{
    20982183        int count_sent=0;
     
    21032188        struct samr_displayentry *users;
    21042189
    2105         char *str1 = param+2;
    2106         char *str2 = skip_string(str1,1);
    2107         char *p = skip_string(str2,1);
     2190        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     2191        char *str2 = skip_string(param,tpscnt,str1);
     2192        char *p = skip_string(param,tpscnt,str2);
     2193
     2194        if (!str1 || !str2 || !p) {
     2195                return False;
     2196        }
    21082197
    21092198        if (strcmp(str1,"WrLeh") != 0)
     
    21172206          */
    21182207 
    2119         resume_context = SVAL(p,0);
    2120         cli_buf_size=SVAL(p+2,0);
     2208        resume_context = get_safe_SVAL(param,tpscnt,p,0,-1);
     2209        cli_buf_size= get_safe_SVAL(param,tpscnt,p,2,0);
    21212210        DEBUG(10,("api_RNetUserEnum:resume context: %d, client buffer size: %d\n",
    21222211                        resume_context, cli_buf_size));
     
    21892278****************************************************************************/
    21902279
    2191 static BOOL api_NetRemoteTOD(connection_struct *conn,uint16 vuid, char *param,char *data,
    2192                              int mdrcnt,int mprcnt,
    2193                              char **rdata,char **rparam,
    2194                              int *rdata_len,int *rparam_len)
     2280static BOOL api_NetRemoteTOD(connection_struct *conn,uint16 vuid,
     2281                                char *param, int tpscnt,
     2282                                char *data, int tdscnt,
     2283                                int mdrcnt,int mprcnt,
     2284                                char **rdata,char **rparam,
     2285                                int *rdata_len,int *rparam_len)
    21952286{
    21962287        struct tm *t;
     
    22452336*****************************************************************************/
    22462337
    2247 static BOOL api_SetUserPassword(connection_struct *conn,uint16 vuid, char *param,char *data,
     2338static BOOL api_SetUserPassword(connection_struct *conn,uint16 vuid,
     2339                                char *param, int tpscnt,
     2340                                char *data, int tdscnt,
    22482341                                int mdrcnt,int mprcnt,
    22492342                                char **rdata,char **rparam,
    22502343                                int *rdata_len,int *rparam_len)
    22512344{
    2252         char *p = skip_string(param+2,2);
     2345        char *np = get_safe_str_ptr(param,tpscnt,param,2);
     2346        char *p = NULL;
    22532347        fstring user;
    22542348        fstring pass1,pass2;
    22552349
     2350        /* Skip 2 strings. */
     2351        p = skip_string(param,tpscnt,np);
     2352        p = skip_string(param,tpscnt,p);
     2353
     2354        if (!np || !p) {
     2355                return False;
     2356        }
     2357
     2358        /* Do we have a string ? */
     2359        if (skip_string(param,tpscnt,p) == NULL) {
     2360                return False;
     2361        }
    22562362        pull_ascii_fstring(user,p);
    22572363
    2258         p = skip_string(p,1);
     2364        p = skip_string(param,tpscnt,p);
     2365        if (!p) {
     2366                return False;
     2367        }
    22592368
    22602369        memset(pass1,'\0',sizeof(pass1));
    22612370        memset(pass2,'\0',sizeof(pass2));
     2371        /*
     2372         * We use 31 here not 32 as we're checking
     2373         * the last byte we want to access is safe.
     2374         */
     2375        if (!is_offset_safe(param,tpscnt,p,31)) {
     2376                return False;
     2377        }
    22622378        memcpy(pass1,p,16);
    22632379        memcpy(pass2,p+16,16);
     
    23312447****************************************************************************/
    23322448
    2333 static BOOL api_SamOEMChangePassword(connection_struct *conn,uint16 vuid, char *param,char *data,
     2449static BOOL api_SamOEMChangePassword(connection_struct *conn,uint16 vuid,
     2450                                char *param, int tpscnt,
     2451                                char *data, int tdscnt,
    23342452                                int mdrcnt,int mprcnt,
    23352453                                char **rdata,char **rparam,
     
    23372455{
    23382456        fstring user;
    2339         char *p = param + 2;
     2457        char *p = get_safe_str_ptr(param,tpscnt,param,2);
    23402458        *rparam_len = 2;
    23412459        *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     
    23442462        }
    23452463
     2464        if (!p) {
     2465                return False;
     2466        }
    23462467        *rdata_len = 0;
    23472468
     
    23522473         */
    23532474
    2354         if(!strequal(param + 2, "zsT")) {
    2355                 DEBUG(0,("api_SamOEMChangePassword: Invalid parameter string %s\n", param + 2));
    2356                 return False;
    2357         }
    2358         p = skip_string(p, 1);
    2359 
     2475        /* Do we have a string ? */
     2476        if (skip_string(param,tpscnt,p) == 0) {
     2477                return False;
     2478        }
     2479        if(!strequal(p, "zsT")) {
     2480                DEBUG(0,("api_SamOEMChangePassword: Invalid parameter string %s\n", p));
     2481                return False;
     2482        }
     2483        p = skip_string(param, tpscnt, p);
     2484        if (!p) {
     2485                return False;
     2486        }
     2487
     2488        /* Do we have a string ? */
     2489        if (skip_string(param,tpscnt,p) == 0) {
     2490                return False;
     2491        }
    23602492        if(!strequal(p, "B516B16")) {
    23612493                DEBUG(0,("api_SamOEMChangePassword: Invalid data parameter string %s\n", p));
    23622494                return False;
    23632495        }
    2364         p = skip_string(p,1);
     2496        p = skip_string(param,tpscnt,p);
     2497        if (!p) {
     2498                return False;
     2499        }
     2500        /* Do we have a string ? */
     2501        if (skip_string(param,tpscnt,p) == 0) {
     2502                return False;
     2503        }
    23652504        p += pull_ascii_fstring(user,p);
    23662505
     
    23862525  ****************************************************************************/
    23872526
    2388 static BOOL api_RDosPrintJobDel(connection_struct *conn,uint16 vuid, char *param,char *data,
     2527static BOOL api_RDosPrintJobDel(connection_struct *conn,uint16 vuid,
     2528                                char *param, int tpscnt,
     2529                                char *data, int tdscnt,
    23892530                                int mdrcnt,int mprcnt,
    23902531                                char **rdata,char **rparam,
    23912532                                int *rdata_len,int *rparam_len)
    23922533{
    2393         int function = SVAL(param,0);
    2394         char *str1 = param+2;
    2395         char *str2 = skip_string(str1,1);
    2396         char *p = skip_string(str2,1);
     2534        int function = get_safe_SVAL(param,tpscnt,param,0,0);
     2535        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     2536        char *str2 = skip_string(param,tpscnt,str1);
     2537        char *p = skip_string(param,tpscnt,str2);
    23972538        uint32 jobid;
    23982539        int snum;
     
    24012542        WERROR werr = WERR_OK;
    24022543
     2544        if (!str1 || !str2 || !p) {
     2545                return False;
     2546        }
     2547        /*
     2548         * We use 1 here not 2 as we're checking
     2549         * the last byte we want to access is safe.
     2550         */
     2551        if (!is_offset_safe(param,tpscnt,p,1)) {
     2552                return False;
     2553        }
    24032554        if(!rap_to_pjobid(SVAL(p,0), sharename, &jobid))
    24042555                return False;
     
    24572608  ****************************************************************************/
    24582609
    2459 static BOOL api_WPrintQueueCtrl(connection_struct *conn,uint16 vuid, char *param,char *data,
    2460                                  int mdrcnt,int mprcnt,
    2461                                  char **rdata,char **rparam,
    2462                                  int *rdata_len,int *rparam_len)
    2463 {
    2464         int function = SVAL(param,0);
    2465         char *str1 = param+2;
    2466         char *str2 = skip_string(str1,1);
    2467         char *QueueName = skip_string(str2,1);
     2610static BOOL api_WPrintQueueCtrl(connection_struct *conn,uint16 vuid,
     2611                                char *param, int tpscnt,
     2612                                char *data, int tdscnt,
     2613                                int mdrcnt,int mprcnt,
     2614                                char **rdata,char **rparam,
     2615                                int *rdata_len,int *rparam_len)
     2616{
     2617        int function = get_safe_SVAL(param,tpscnt,param,0,0);
     2618        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     2619        char *str2 = skip_string(param,tpscnt,str1);
     2620        char *QueueName = skip_string(param,tpscnt,str2);
    24682621        int errcode = NERR_notsupported;
    24692622        int snum;
    24702623        WERROR werr = WERR_OK;
    24712624
     2625        if (!str1 || !str2 || !QueueName) {
     2626                return False;
     2627        }
     2628
    24722629        /* check it's a supported varient */
    24732630        if (!(strcsequal(str1,"z") && strcsequal(str2,"")))
     
    24812638        *rdata_len = 0;
    24822639
     2640        if (skip_string(param,tpscnt,QueueName) == NULL) {
     2641                return False;
     2642        }
    24832643        snum = print_queue_snum(QueueName);
    24842644
     
    25272687        case 3: desc->format = "WWzWWDDzzzzzzzzzzlz"; break;
    25282688        case 4: desc->format = "WWzWWDDzzzzzDDDDDDD"; break;
    2529         default: return False;
    2530         }
    2531         if (strcmp(desc->format,id) != 0) return False;
     2689        default:
     2690                DEBUG(0,("check_printjob_info: invalid level %d\n",
     2691                        uLevel ));
     2692                return False;
     2693        }
     2694        if (id == NULL || strcmp(desc->format,id) != 0) {
     2695                DEBUG(0,("check_printjob_info: invalid format %s\n",
     2696                        id ? id : "<NULL>" ));
     2697                return False;
     2698        }
    25322699        return True;
    25332700}
    25342701
    2535 static BOOL api_PrintJobInfo(connection_struct *conn,uint16 vuid,char *param,char *data,
    2536                              int mdrcnt,int mprcnt,
    2537                              char **rdata,char **rparam,
    2538                              int *rdata_len,int *rparam_len)
     2702static BOOL api_PrintJobInfo(connection_struct *conn, uint16 vuid,
     2703                                char *param, int tpscnt,
     2704                                char *data, int tdscnt,
     2705                                int mdrcnt,int mprcnt,
     2706                                char **rdata,char **rparam,
     2707                                int *rdata_len,int *rparam_len)
    25392708{
    25402709        struct pack_desc desc;
    2541         char *str1 = param+2;
    2542         char *str2 = skip_string(str1,1);
    2543         char *p = skip_string(str2,1);
     2710        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     2711        char *str2 = skip_string(param,tpscnt,str1);
     2712        char *p = skip_string(param,tpscnt,str2);
    25442713        uint32 jobid;
    25452714        fstring sharename;
    2546         int uLevel = SVAL(p,2);
    2547         int function = SVAL(p,4);
     2715        int uLevel = get_safe_SVAL(param,tpscnt,p,2,-1);
     2716        int function = get_safe_SVAL(param,tpscnt,p,4,-1);
    25482717        int place, errcode;
    25492718
     2719        if (!str1 || !str2 || !p) {
     2720                return False;
     2721        }
     2722        /*
     2723         * We use 1 here not 2 as we're checking
     2724         * the last byte we want to access is safe.
     2725         */
     2726        if (!is_offset_safe(param,tpscnt,p,1)) {
     2727                return False;
     2728        }
    25502729        if(!rap_to_pjobid(SVAL(p,0), sharename, &jobid))
    25512730                return False;
     
    26092788****************************************************************************/
    26102789
    2611 static BOOL api_RNetServerGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
    2612                                   int mdrcnt,int mprcnt,
    2613                                   char **rdata,char **rparam,
    2614                                   int *rdata_len,int *rparam_len)
    2615 {
    2616         char *str1 = param+2;
    2617         char *str2 = skip_string(str1,1);
    2618         char *p = skip_string(str2,1);
    2619         int uLevel = SVAL(p,0);
     2790static BOOL api_RNetServerGetInfo(connection_struct *conn,uint16 vuid,
     2791                                char *param, int tpscnt,
     2792                                char *data, int tdscnt,
     2793                                int mdrcnt,int mprcnt,
     2794                                char **rdata,char **rparam,
     2795                                int *rdata_len,int *rparam_len)
     2796{
     2797        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     2798        char *str2 = skip_string(param,tpscnt,str1);
     2799        char *p = skip_string(param,tpscnt,str2);
     2800        int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
    26202801        char *p2;
    26212802        int struct_len;
     2803
     2804        if (!str1 || !str2 || !p) {
     2805                return False;
     2806        }
    26222807
    26232808        DEBUG(4,("NetServerGetInfo level %d\n",uLevel));
     
    27152900                                              comment, sizeof(comment));
    27162901                        StrnCpy(p2,comment,MAX(mdrcnt - struct_len,0));
    2717                         p2 = skip_string(p2,1);
     2902                        p2 = skip_string(*rdata,*rdata_len,p2);
     2903                        if (!p2) {
     2904                                return False;
     2905                        }
    27182906                }
    27192907        }
     
    27412929****************************************************************************/
    27422930
    2743 static BOOL api_NetWkstaGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
     2931static BOOL api_NetWkstaGetInfo(connection_struct *conn,uint16 vuid,
     2932                                char *param, int tpscnt,
     2933                                char *data, int tdscnt,
    27442934                                int mdrcnt,int mprcnt,
    27452935                                char **rdata,char **rparam,
    27462936                                int *rdata_len,int *rparam_len)
    27472937{
    2748         char *str1 = param+2;
    2749         char *str2 = skip_string(str1,1);
    2750         char *p = skip_string(str2,1);
     2938        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     2939        char *str2 = skip_string(param,tpscnt,str1);
     2940        char *p = skip_string(param,tpscnt,str2);
    27512941        char *p2;
    2752         int level = SVAL(p,0);
     2942        int level = get_safe_SVAL(param,tpscnt,p,0,-1);
     2943
     2944        if (!str1 || !str2 || !p) {
     2945                return False;
     2946        }
    27532947
    27542948        DEBUG(4,("NetWkstaGetInfo level %d\n",level));
     
    27752969
    27762970        p = *rdata;
    2777         p2 = p + 22;
     2971        p2 = get_safe_ptr(*rdata,*rdata_len,p,22);
     2972        if (!p2) {
     2973                return False;
     2974        }
    27782975
    27792976        SIVAL(p,0,PTR_DIFF(p2,*rdata)); /* host name */
    27802977        pstrcpy(p2,get_local_machine_name());
    27812978        strupper_m(p2);
    2782         p2 = skip_string(p2,1);
     2979        p2 = skip_string(*rdata,*rdata_len,p2);
     2980        if (!p2) {
     2981                return False;
     2982        }
    27832983        p += 4;
    27842984
    27852985        SIVAL(p,0,PTR_DIFF(p2,*rdata));
    27862986        pstrcpy(p2,current_user_info.smb_name);
    2787         p2 = skip_string(p2,1);
     2987        p2 = skip_string(*rdata,*rdata_len,p2);
     2988        if (!p2) {
     2989                return False;
     2990        }
    27882991        p += 4;
    27892992
     
    27912994        pstrcpy(p2,lp_workgroup());
    27922995        strupper_m(p2);
    2793         p2 = skip_string(p2,1);
     2996        p2 = skip_string(*rdata,*rdata_len,p2);
     2997        if (!p2) {
     2998                return False;
     2999        }
    27943000        p += 4;
    27953001
     
    28003006        SIVAL(p,0,PTR_DIFF(p2,*rdata));
    28013007        pstrcpy(p2,lp_workgroup());     /* don't know.  login domain?? */
    2802         p2 = skip_string(p2,1);
     3008        p2 = skip_string(*rdata,*rdata_len,p2);
     3009        if (!p2) {
     3010                return False;
     3011        }
    28033012        p += 4;
    28043013
    28053014        SIVAL(p,0,PTR_DIFF(p2,*rdata)); /* don't know */
    28063015        pstrcpy(p2,"");
    2807         p2 = skip_string(p2,1);
     3016        p2 = skip_string(*rdata,*rdata_len,p2);
     3017        if (!p2) {
     3018                return False;
     3019        }
    28083020        p += 4;
    28093021
     
    29873199
    29883200
    2989 static BOOL api_RNetUserGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
     3201static BOOL api_RNetUserGetInfo(connection_struct *conn, uint16 vuid,
     3202                                char *param, int tpscnt,
     3203                                char *data, int tdscnt,
    29903204                                int mdrcnt,int mprcnt,
    29913205                                char **rdata,char **rparam,
    29923206                                int *rdata_len,int *rparam_len)
    29933207{
    2994         char *str1 = param+2;
    2995         char *str2 = skip_string(str1,1);
    2996         char *UserName = skip_string(str2,1);
    2997         char *p = skip_string(UserName,1);
    2998         int uLevel = SVAL(p,0);
     3208        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     3209        char *str2 = skip_string(param,tpscnt,str1);
     3210        char *UserName = skip_string(param,tpscnt,str2);
     3211        char *p = skip_string(param,tpscnt,UserName);
     3212        int uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
    29993213        char *p2;
    30003214        const char *level_string;
     
    30093223        }
    30103224
     3225        if (!str1 || !str2 || !UserName || !p) {
     3226                return False;
     3227        }
     3228
    30113229        *rparam_len = 6;
    30123230        *rparam = SMB_REALLOC_LIMIT(*rparam,*rparam_len);
     
    30443262
    30453263        p = *rdata;
    3046         p2 = p + usri11_end;
     3264        p2 = get_safe_ptr(*rdata,*rdata_len,p,usri11_end);
     3265        if (!p2) {
     3266                return False;
     3267        }
    30473268
    30483269        memset(p,0,21);
     
    30573278                SIVAL(p,usri11_comment,PTR_DIFF(p2,p)); /* comment */
    30583279                pstrcpy(p2,"Comment");
    3059                 p2 = skip_string(p2,1);
     3280                p2 = skip_string(*rdata,*rdata_len,p2);
     3281                if (!p2) {
     3282                        return False;
     3283                }
    30603284
    30613285                SIVAL(p,usri11_usr_comment,PTR_DIFF(p2,p)); /* user_comment */
    30623286                pstrcpy(p2,"UserComment");
    3063                 p2 = skip_string(p2,1);
     3287                p2 = skip_string(*rdata,*rdata_len,p2);
     3288                if (!p2) {
     3289                        return False;
     3290                }
    30643291
    30653292                /* EEK! the cifsrap.txt doesn't have this in!!!! */
    30663293                SIVAL(p,usri11_full_name,PTR_DIFF(p2,p)); /* full name */
    30673294                pstrcpy(p2,((vuser != NULL) ? vuser->user.full_name : UserName));
    3068                 p2 = skip_string(p2,1);
     3295                p2 = skip_string(*rdata,*rdata_len,p2);
     3296                if (!p2) {
     3297                        return False;
     3298                }
    30693299        }
    30703300
     
    30763306                SIVAL(p,usri11_homedir,PTR_DIFF(p2,p)); /* home dir */
    30773307                pstrcpy(p2, vuser && vuser->homedir ? vuser->homedir : "");
    3078                 p2 = skip_string(p2,1);
     3308                p2 = skip_string(*rdata,*rdata_len,p2);
     3309                if (!p2) {
     3310                        return False;
     3311                }
    30793312                SIVAL(p,usri11_parms,PTR_DIFF(p2,p)); /* parms */
    30803313                pstrcpy(p2,"");
    3081                 p2 = skip_string(p2,1);
     3314                p2 = skip_string(*rdata,*rdata_len,p2);
     3315                if (!p2) {
     3316                        return False;
     3317                }
    30823318                SIVAL(p,usri11_last_logon,0);           /* last logon */
    30833319                SIVAL(p,usri11_last_logoff,0);          /* last logoff */
     
    30863322                SIVAL(p,usri11_logon_server,PTR_DIFF(p2,p)); /* logon server */
    30873323                pstrcpy(p2,"\\\\*");
    3088                 p2 = skip_string(p2,1);
     3324                p2 = skip_string(*rdata,*rdata_len,p2);
     3325                if (!p2) {
     3326                        return False;
     3327                }
    30893328                SSVAL(p,usri11_country_code,0);         /* country code */
    30903329
    30913330                SIVAL(p,usri11_workstations,PTR_DIFF(p2,p)); /* workstations */
    30923331                pstrcpy(p2,"");
    3093                 p2 = skip_string(p2,1);
     3332                p2 = skip_string(*rdata,*rdata_len,p2);
     3333                if (!p2) {
     3334                        return False;
     3335                }
    30943336
    30953337                SIVALS(p,usri11_max_storage,-1);                /* max storage */
     
    31003342                memset(p2,0xff,21);
    31013343                SCVAL(p2,21,0);           /* fix zero termination */
    3102                 p2 = skip_string(p2,1);
     3344                p2 = skip_string(*rdata,*rdata_len,p2);
     3345                if (!p2) {
     3346                        return False;
     3347                }
    31033348
    31043349                SSVAL(p,usri11_code_page,0);            /* code page */
     
    31123357                SIVAL(p,44,PTR_DIFF(p2,*rdata)); /* home dir */
    31133358                pstrcpy(p2, vuser && vuser->homedir ? vuser->homedir : "");
    3114                 p2 = skip_string(p2,1);
     3359                p2 = skip_string(*rdata,*rdata_len,p2);
     3360                if (!p2) {
     3361                        return False;
     3362                }
    31153363                SIVAL(p,48,PTR_DIFF(p2,*rdata)); /* comment */
    31163364                *p2++ = 0;
     
    31183366                SIVAL(p,54,PTR_DIFF(p2,*rdata));                /* script_path */
    31193367                pstrcpy(p2,vuser && vuser->logon_script ? vuser->logon_script : "");
    3120                 p2 = skip_string(p2,1);
     3368                p2 = skip_string(*rdata,*rdata_len,p2);
     3369                if (!p2) {
     3370                        return False;
     3371                }
    31213372                if (uLevel == 2) {
    31223373                        SIVAL(p,60,0);          /* auth_flags */
    31233374                        SIVAL(p,64,PTR_DIFF(p2,*rdata)); /* full_name */
    31243375                        pstrcpy(p2,((vuser != NULL) ? vuser->user.full_name : UserName));
    3125                         p2 = skip_string(p2,1);
     3376                        p2 = skip_string(*rdata,*rdata_len,p2);
     3377                        if (!p2) {
     3378                                return False;
     3379                        }
    31263380                        SIVAL(p,68,0);          /* urs_comment */
    31273381                        SIVAL(p,72,PTR_DIFF(p2,*rdata)); /* parms */
    31283382                        pstrcpy(p2,"");
    3129                         p2 = skip_string(p2,1);
     3383                        p2 = skip_string(*rdata,*rdata_len,p2);
     3384                        if (!p2) {
     3385                                return False;
     3386                        }
    31303387                        SIVAL(p,76,0);          /* workstations */
    31313388                        SIVAL(p,80,0);          /* last_logon */
     
    31463403                                pstrcpy(p2, tmp);
    31473404                        }
    3148                         p2 = skip_string(p2,1);
     3405                        p2 = skip_string(*rdata,*rdata_len,p2);
     3406                        if (!p2) {
     3407                                return False;
     3408                        }
    31493409                        SSVAL(p,110,49);        /* country_code */
    31503410                        SSVAL(p,112,860);       /* code page */
     
    31593419}
    31603420
    3161 static BOOL api_WWkstaUserLogon(connection_struct *conn,uint16 vuid, char *param,char *data,
     3421static BOOL api_WWkstaUserLogon(connection_struct *conn,uint16 vuid,
     3422                                char *param, int tpscnt,
     3423                                char *data, int tdscnt,
    31623424                                int mdrcnt,int mprcnt,
    31633425                                char **rdata,char **rparam,
    31643426                                int *rdata_len,int *rparam_len)
    31653427{
    3166         char *str1 = param+2;
    3167         char *str2 = skip_string(str1,1);
    3168         char *p = skip_string(str2,1);
     3428        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     3429        char *str2 = skip_string(param,tpscnt,str1);
     3430        char *p = skip_string(param,tpscnt,str2);
    31693431        int uLevel;
    31703432        struct pack_desc desc;
     
    31743436        user_struct *vuser = get_valid_user_struct(vuid);
    31753437
     3438        if (!str1 || !str2 || !p) {
     3439                return False;
     3440        }
     3441
    31763442        if(vuser != NULL) {
    31773443                DEBUG(3,("  Username of UID %d is %s\n", (int)vuser->uid,
     
    31793445        }
    31803446
    3181         uLevel = SVAL(p,0);
    3182         name = p + 2;
     3447        uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
     3448        name = get_safe_str_ptr(param,tpscnt,p,2);
     3449        if (!name) {
     3450                return False;
     3451        }
    31833452
    31843453        memset((char *)&desc,'\0',sizeof(desc));
     
    32533522****************************************************************************/
    32543523
    3255 static BOOL api_WAccessGetUserPerms(connection_struct *conn,uint16 vuid, char *param,char *data,
    3256                                     int mdrcnt,int mprcnt,
    3257                                     char **rdata,char **rparam,
    3258                                     int *rdata_len,int *rparam_len)
    3259 {
    3260         char *str1 = param+2;
    3261         char *str2 = skip_string(str1,1);
    3262         char *user = skip_string(str2,1);
    3263         char *resource = skip_string(user,1);
    3264 
     3524static BOOL api_WAccessGetUserPerms(connection_struct *conn,uint16 vuid,
     3525                                char *param, int tpscnt,
     3526                                char *data, int tdscnt,
     3527                                int mdrcnt,int mprcnt,
     3528                                char **rdata,char **rparam,
     3529                                int *rdata_len,int *rparam_len)
     3530{
     3531        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     3532        char *str2 = skip_string(param,tpscnt,str1);
     3533        char *user = skip_string(param,tpscnt,str2);
     3534        char *resource = skip_string(param,tpscnt,user);
     3535
     3536        if (!str1 || !str2 || !user || !resource) {
     3537                return False;
     3538        }
     3539
     3540        if (skip_string(param,tpscnt,resource) == NULL) {
     3541                return False;
     3542        }
    32653543        DEBUG(3,("WAccessGetUserPerms user=%s resource=%s\n",user,resource));
    32663544
     
    32893567  ****************************************************************************/
    32903568
    3291 static BOOL api_WPrintJobGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
    3292                                  int mdrcnt,int mprcnt,
    3293                                  char **rdata,char **rparam,
    3294                                  int *rdata_len,int *rparam_len)
    3295 {
    3296         char *str1 = param+2;
    3297         char *str2 = skip_string(str1,1);
    3298         char *p = skip_string(str2,1);
     3569static BOOL api_WPrintJobGetInfo(connection_struct *conn, uint16 vuid,
     3570                                char *param, int tpscnt,
     3571                                char *data, int tdscnt,
     3572                                int mdrcnt,int mprcnt,
     3573                                char **rdata,char **rparam,
     3574                                int *rdata_len,int *rparam_len)
     3575{
     3576        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     3577        char *str2 = skip_string(param,tpscnt,str1);
     3578        char *p = skip_string(param,tpscnt,str2);
    32993579        int uLevel;
    33003580        int count;
     
    33083588        char *tmpdata=NULL;
    33093589
    3310         uLevel = SVAL(p,2);
     3590        if (!str1 || !str2 || !p) {
     3591                return False;
     3592        }
     3593
     3594        uLevel = get_safe_SVAL(param,tpscnt,p,2,-1);
    33113595
    33123596        memset((char *)&desc,'\0',sizeof(desc));
     
    33823666}
    33833667
    3384 static BOOL api_WPrintJobEnumerate(connection_struct *conn,uint16 vuid, char *param,char *data,
    3385                                    int mdrcnt,int mprcnt,
    3386                                    char **rdata,char **rparam,
    3387                                    int *rdata_len,int *rparam_len)
    3388 {
    3389         char *str1 = param+2;
    3390         char *str2 = skip_string(str1,1);
    3391         char *p = skip_string(str2,1);
    3392         char* name = p;
     3668static BOOL api_WPrintJobEnumerate(connection_struct *conn, uint16 vuid,
     3669                                char *param, int tpscnt,
     3670                                char *data, int tdscnt,
     3671                                int mdrcnt,int mprcnt,
     3672                                char **rdata,char **rparam,
     3673                                int *rdata_len,int *rparam_len)
     3674{
     3675        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     3676        char *str2 = skip_string(param,tpscnt,str1);
     3677        char *p = skip_string(param,tpscnt,str2);
     3678        char *name = p;
    33933679        int uLevel;
    33943680        int count;
     
    33993685        print_status_struct status;
    34003686
     3687        if (!str1 || !str2 || !p) {
     3688                return False;
     3689        }
     3690
    34013691        memset((char *)&desc,'\0',sizeof(desc));
    34023692        memset((char *)&status,'\0',sizeof(status));
    34033693
    3404         p = skip_string(p,1);
    3405         uLevel = SVAL(p,0);
     3694        p = skip_string(param,tpscnt,p);
     3695        if (!p) {
     3696                return False;
     3697        }
     3698        uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
    34063699
    34073700        DEBUG(3,("WPrintJobEnumerate uLevel=%d name=%s\n",uLevel,name));
     
    34823775                        break;
    34833776                default:
     3777                        DEBUG(0,("check_printdest_info: invalid level %d\n",
     3778                                uLevel));
    34843779                        return False;
    34853780        }
    3486         if (strcmp(desc->format,id) != 0) {
     3781        if (id == NULL || strcmp(desc->format,id) != 0) {
     3782                DEBUG(0,("check_printdest_info: invalid string %s\n",
     3783                        id ? id : "<NULL>" ));
    34873784                return False;
    34883785        }
     
    35263823}
    35273824
    3528 static BOOL api_WPrintDestGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
    3529                                   int mdrcnt,int mprcnt,
    3530                                   char **rdata,char **rparam,
    3531                                   int *rdata_len,int *rparam_len)
    3532 {
    3533         char *str1 = param+2;
    3534         char *str2 = skip_string(str1,1);
    3535         char *p = skip_string(str2,1);
     3825static BOOL api_WPrintDestGetInfo(connection_struct *conn, uint16 vuid,
     3826                                char *param, int tpscnt,
     3827                                char *data, int tdscnt,
     3828                                int mdrcnt,int mprcnt,
     3829                                char **rdata,char **rparam,
     3830                                int *rdata_len,int *rparam_len)
     3831{
     3832        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     3833        char *str2 = skip_string(param,tpscnt,str1);
     3834        char *p = skip_string(param,tpscnt,str2);
    35363835        char* PrinterName = p;
    35373836        int uLevel;
     
    35403839        char *tmpdata=NULL;
    35413840
     3841        if (!str1 || !str2 || !p) {
     3842                return False;
     3843        }
     3844
    35423845        memset((char *)&desc,'\0',sizeof(desc));
    35433846
    3544         p = skip_string(p,1);
    3545         uLevel = SVAL(p,0);
     3847        p = skip_string(param,tpscnt,p);
     3848        if (!p) {
     3849                return False;
     3850        }
     3851        uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
    35463852
    35473853        DEBUG(3,("WPrintDestGetInfo uLevel=%d PrinterName=%s\n",uLevel,PrinterName));
     
    35973903}
    35983904
    3599 static BOOL api_WPrintDestEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
    3600                                int mdrcnt,int mprcnt,
    3601                                char **rdata,char **rparam,
    3602                                int *rdata_len,int *rparam_len)
    3603 {
    3604         char *str1 = param+2;
    3605         char *str2 = skip_string(str1,1);
    3606         char *p = skip_string(str2,1);
     3905static BOOL api_WPrintDestEnum(connection_struct *conn, uint16 vuid,
     3906                                char *param, int tpscnt,
     3907                                char *data, int tdscnt,
     3908                                int mdrcnt,int mprcnt,
     3909                                char **rdata,char **rparam,
     3910                                int *rdata_len,int *rparam_len)
     3911{
     3912        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     3913        char *str2 = skip_string(param,tpscnt,str1);
     3914        char *p = skip_string(param,tpscnt,str2);
    36073915        int uLevel;
    36083916        int queuecnt;
     
    36113919        int services = lp_numservices();
    36123920
     3921        if (!str1 || !str2 || !p) {
     3922                return False;
     3923        }
     3924
    36133925        memset((char *)&desc,'\0',sizeof(desc));
    36143926
    3615         uLevel = SVAL(p,0);
     3927        uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
    36163928
    36173929        DEBUG(3,("WPrintDestEnum uLevel=%d\n",uLevel));
     
    36723984}
    36733985
    3674 static BOOL api_WPrintDriverEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
    3675                                  int mdrcnt,int mprcnt,
    3676                                  char **rdata,char **rparam,
    3677                                  int *rdata_len,int *rparam_len)
    3678 {
    3679         char *str1 = param+2;
    3680         char *str2 = skip_string(str1,1);
    3681         char *p = skip_string(str2,1);
     3986static BOOL api_WPrintDriverEnum(connection_struct *conn, uint16 vuid,
     3987                                char *param, int tpscnt,
     3988                                char *data, int tdscnt,
     3989                                int mdrcnt,int mprcnt,
     3990                                char **rdata,char **rparam,
     3991                                int *rdata_len,int *rparam_len)
     3992{
     3993        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     3994        char *str2 = skip_string(param,tpscnt,str1);
     3995        char *p = skip_string(param,tpscnt,str2);
    36823996        int uLevel;
    36833997        int succnt;
    36843998        struct pack_desc desc;
    36853999
     4000        if (!str1 || !str2 || !p) {
     4001                return False;
     4002        }
     4003
    36864004        memset((char *)&desc,'\0',sizeof(desc));
    36874005
    3688         uLevel = SVAL(p,0);
     4006        uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
    36894007
    36904008        DEBUG(3,("WPrintDriverEnum uLevel=%d\n",uLevel));
     
    37294047}
    37304048
    3731 static BOOL api_WPrintQProcEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
     4049static BOOL api_WPrintQProcEnum(connection_struct *conn, uint16 vuid,
     4050                                char *param, int tpscnt,
     4051                                char *data, int tdscnt,
    37324052                                int mdrcnt,int mprcnt,
    37334053                                char **rdata,char **rparam,
    37344054                                int *rdata_len,int *rparam_len)
    37354055{
    3736         char *str1 = param+2;
    3737         char *str2 = skip_string(str1,1);
    3738         char *p = skip_string(str2,1);
     4056        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     4057        char *str2 = skip_string(param,tpscnt,str1);
     4058        char *p = skip_string(param,tpscnt,str2);
    37394059        int uLevel;
    37404060        int succnt;
    37414061        struct pack_desc desc;
    37424062
     4063        if (!str1 || !str2 || !p) {
     4064                return False;
     4065        }
    37434066        memset((char *)&desc,'\0',sizeof(desc));
    37444067
    3745         uLevel = SVAL(p,0);
     4068        uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
    37464069
    37474070        DEBUG(3,("WPrintQProcEnum uLevel=%d\n",uLevel));
     
    37874110}
    37884111
    3789 static BOOL api_WPrintPortEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
    3790                                int mdrcnt,int mprcnt,
    3791                                char **rdata,char **rparam,
    3792                                int *rdata_len,int *rparam_len)
    3793 {
    3794         char *str1 = param+2;
    3795         char *str2 = skip_string(str1,1);
    3796         char *p = skip_string(str2,1);
     4112static BOOL api_WPrintPortEnum(connection_struct *conn, uint16 vuid,
     4113                                char *param, int tpscnt,
     4114                                char *data, int tdscnt,
     4115                                int mdrcnt,int mprcnt,
     4116                                char **rdata,char **rparam,
     4117                                int *rdata_len,int *rparam_len)
     4118{
     4119        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     4120        char *str2 = skip_string(param,tpscnt,str1);
     4121        char *p = skip_string(param,tpscnt,str2);
    37974122        int uLevel;
    37984123        int succnt;
    37994124        struct pack_desc desc;
    38004125
     4126        if (!str1 || !str2 || !p) {
     4127                return False;
     4128        }
     4129
    38014130        memset((char *)&desc,'\0',sizeof(desc));
    38024131
    3803         uLevel = SVAL(p,0);
     4132        uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
    38044133
    38054134        DEBUG(3,("WPrintPortEnum uLevel=%d\n",uLevel));
     
    38464175}
    38474176
    3848 
    38494177/****************************************************************************
    38504178 List open sessions
    38514179 ****************************************************************************/
    3852 static BOOL api_RNetSessionEnum(connection_struct *conn,uint16 vuid, char *param, char *data,
    3853                                int mdrcnt,int mprcnt,
    3854                                char **rdata,char **rparam,
    3855                                int *rdata_len,int *rparam_len)
    3856 
    3857 {
    3858         char *str1 = param+2;
    3859         char *str2 = skip_string(str1,1);
    3860         char *p = skip_string(str2,1);
     4180
     4181static BOOL api_RNetSessionEnum(connection_struct *conn, uint16 vuid,
     4182                                char *param, int tpscnt,
     4183                                char *data, int tdscnt,
     4184                                int mdrcnt,int mprcnt,
     4185                                char **rdata,char **rparam,
     4186                                int *rdata_len,int *rparam_len)
     4187
     4188{
     4189        char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
     4190        char *str2 = skip_string(param,tpscnt,str1);
     4191        char *p = skip_string(param,tpscnt,str2);
    38614192        int uLevel;
    38624193        struct pack_desc desc;
     
    38644195        int i, num_sessions;
    38654196
     4197        if (!str1 || !str2 || !p) {
     4198                return False;
     4199        }
     4200
    38664201        memset((char *)&desc,'\0',sizeof(desc));
    38674202
    3868         uLevel = SVAL(p,0);
     4203        uLevel = get_safe_SVAL(param,tpscnt,p,0,-1);
    38694204
    38704205        DEBUG(3,("RNetSessionEnum uLevel=%d\n",uLevel));
     
    39534288 ****************************************************************************/
    39544289
    3955 static BOOL api_Unsupported(connection_struct *conn, uint16 vuid, char *param, char *data,
    3956                             int mdrcnt, int mprcnt,
    3957                             char **rdata, char **rparam,
    3958                             int *rdata_len, int *rparam_len)
     4290static BOOL api_Unsupported(connection_struct *conn, uint16 vuid,
     4291                                char *param, int tpscnt,
     4292                                char *data, int tdscnt,
     4293                                int mdrcnt, int mprcnt,
     4294                                char **rdata, char **rparam,
     4295                                int *rdata_len, int *rparam_len)
    39594296{
    39604297        *rparam_len = 4;
     
    39774314        const char *name;
    39784315        int id;
    3979         BOOL (*fn)(connection_struct *,uint16,char *,char *,
     4316        BOOL (*fn)(connection_struct *, uint16,
     4317                        char *, int,
     4318                        char *, int,
    39804319                        int,int,char **,char **,int *,int *);
    39814320        BOOL auth_user;         /* Deny anonymous access? */
     
    40324371        char *rdata = NULL;
    40334372        char *rparam = NULL;
     4373        const char *name1 = NULL;
     4374        const char *name2 = NULL;
    40344375        int rdata_len = 0;
    40354376        int rparam_len = 0;
     
    40424383        }
    40434384
     4385        if (tpscnt < 2) {
     4386                return 0;
     4387        }
    40444388        api_command = SVAL(params,0);
     4389        /* Is there a string at position params+2 ? */
     4390        if (skip_string(params,tpscnt,params+2)) {
     4391                name1 = params + 2;
     4392        } else {
     4393                name1 = "";
     4394        }
     4395        name2 = skip_string(params,tpscnt,params+2);
     4396        if (!name2) {
     4397                name2 = "";
     4398        }
    40454399
    40464400        DEBUG(3,("Got API command %d of form <%s> <%s> (tdscnt=%d,tpscnt=%d,mdrcnt=%d,mprcnt=%d)\n",
    40474401                api_command,
    4048                 params+2,
    4049                 skip_string(params+2,1),
     4402                name1,
     4403                name2,
    40504404                tdscnt,tpscnt,mdrcnt,mprcnt));
    40514405
     
    40844438        }
    40854439
    4086         reply = api_commands[i].fn(conn,vuid,params,data,mdrcnt,mprcnt,
     4440        reply = api_commands[i].fn(conn,
     4441                                vuid,
     4442                                params,tpscnt,  /* params + length */
     4443                                data,tdscnt,    /* data + length */
     4444                                mdrcnt,mprcnt,
    40874445                                &rdata,&rparam,&rdata_len,&rparam_len);
    40884446
     
    40954453        /* if we get False back then it's actually unsupported */
    40964454        if (!reply) {
    4097                 reply = api_Unsupported(conn,vuid,params,data,mdrcnt,mprcnt,
     4455                reply = api_Unsupported(conn,vuid,params,tpscnt,data,tdscnt,mdrcnt,mprcnt,
    40984456                        &rdata,&rparam,&rdata_len,&rparam_len);
    40994457        }
Note: See TracChangeset for help on using the changeset viewer.