Changeset 145


Ignore:
Timestamp:
Aug 16, 2008, 12:11:48 PM (17 years ago)
Author:
Yuri Dario
Message:

Merged daemon code, now the plugin calls directly samba client library (still using smbrp code).

Location:
branches/client-1.5/src
Files:
2 added
9 deleted
4 edited

Legend:

Unmodified
Added
Removed

  • branches/client-1.5/src/makefile

    r23 r145  
    22# gcc 3.3.5 is required!
    33#
     4# for release build:
     5#       make
     6#
     7# for debug build:
     8#       make DEBUG=1
     9#
    410
    5 VERSION         = 1.0.15
    6 BUILD           = 15
     11VERSION         = 1.4.9
     12BUILD           = alpha1
    713
    8 SAMBA           = ..
    9 TOOLKIT         = E:\dev\toolkit452
     14SAMBA           = ../../samba-3.0/source
     15TOOLKIT         = f:\dev\toolkit452
    1016
    1117INCLUDES        = -I.\h -I.\rc \
    … …  
    1622                -I$(SAMBA)/tdb/include
    1723
    18 CFLAGS = -g -Zomf -O3 -march=pentium -mcpu=pentium4
     24ifdef DEBUG
     25CFLAGS = -g -Zomf -O0 -march=pentium -mcpu=pentium4 -DDEBUG_PRINTF
     26LDFLAGS = -g -Zomf -Zno-fork -Zsym -Zmap -Zbin-files
     27else
     28CFLAGS = -s -Zomf -O3 -march=pentium -mcpu=pentium4
    1929LDFLAGS = -s -Zomf -Zno-fork -Zsym -Zmap -Zbin-files
     30endif
    2031
    2132CC              =      gcc
    22 LIBS            =      $(SAMBA)/bin/libsmbclient.a -lsocket -lsyslog
     33LIBS            =      $(SAMBA)/bin/libsmbclient.a -lsocket
    2334
    24 NDPSMB_OBJS = ndpsmb.o
    25 SMBCD_OBJS = smbcd.o smbwrp.o
     35NDPSMB_OBJS = ndpsmb.o debug.o smbwrp.o
    2636
     37ifdef DEBUG
     38NDPSMB_OBJS += printf.o
     39endif
    2740
    28 all: ndpsmb.dll ndpsmb.hlp smbcd.exe
     41all: ndpsmb.dll ndpsmb.hlp
    2942
    3043.c.o:
    … …  
    3245
    3346ndpsmb.dll: $(NDPSMB_OBJS) ndpsmb.def rc\rc.res makefile
    34         $(CC) -Zdll $(LDFLAGS) -o $@ $(NDPSMB_OBJS) rc\rc.res ndpsmb.def
    35 
    36 smbcd.exe: $(SMBCD_OBJS) rc\rc.res makefile
    37         $(CC) -Zexe $(LDFLAGS) -o $@ $(LIBS) $(SMBCD_OBJS) rc\rc.res
     47        $(CC) -Zdll $(LDFLAGS) -o $@ $(NDPSMB_OBJS) $(LIBS) rc\rc.res ndpsmb.def
    3848
    3949rc\description.rc: makefile
    40         call BldLevelInf -V$(VERSION) -N"Netlabs.org" -D"NDPSMB - SMBFS NetDrive External Plugin" -Len rc\description.rc
     50        call BldLevelInf -V$(VERSION) -N"Netlabs.org" -D"NDPSMB - SMBFS NetDrive External Plugin $(BUILD)" -Len rc\description.rc
    4151
    4252rc\rc.res: .\rc\rc.rc .\rc\rc.dlg .\rc\rc.h .\H\ndpl_rc.h rc\description.rc
    … …  
    5262
    5363clean:
    54         rm *.obj
     64        rm -f *.obj *.o
    5565        rm *.map
    5666        rm *.dll
    5767        rm *.hlp
     68

  • branches/client-1.5/src/ndpsmb.c

    r131 r145  
     1#include <stdio.h>
     2#include <stdlib.h>
     3#include <stdarg.h>
     4#include <time.h>
     5
    16#define NDPL_LARGEFILES
    27#define INCL_LONGLONG
    38#include <ndextpl2.h>
    49#include <smbwrp.h>
    5 #include <smbcd.h>
    6 #include <stdio.h>
    7 #include <stdlib.h>
    8 #include <stdarg.h>
    9 #include <time.h>
    10 
    11 
    12 #define NULL ((void *)0)
    1310
    1411#ifndef DEBUG_PRINTF
    … …  
    1613#endif
    1714
     15#define log debug_printf
     16
     17#if 0
    1818void log(const char *fmt, ...)
    1919{ 
    … …  
    4242        }
    4343}
     44#endif
    4445
    4546// -------------------------------------------------------------
    … …  
    253254}
    254255
    255 typedef struct _Resource
    256 {
    257         /* NetDrive information */
    258         NDPROPERTYHANDLE properties;    /* access handle for the properties */
    259         int rootlevel;
    260         unsigned long memlen;
    261         unsigned long objany;
    262         smbwrp_server srv;
    263         char logfile[CCHMAXPATH + 1];
    264         char loglevel;
    265         int easupport;
    266 } Resource;
    267 
    268 typedef struct _Connection
    269 {
    270         Resource *pRes;
    271         HPIPE pipe;
    272         char * mem;
    273         int clientpid;
    274         int rc;
    275         smbwrp_server srv;
    276         smbwrp_file file;
    277 } Connection;
    278 
    279 int openpipe(Resource * pRes, HPIPE * ppipe)
    280 {
    281         HPIPE pipe = 0;
    282         unsigned long rc = 0, action;
    283 
    284         if (!pRes)
    285         {
    286                 return ERROR_INVALID_PARAMETER;
    287         }
    288 
    289         rc = DosOpen(PIPENAME, &pipe, &action, 0, 0, OPEN_ACTION_OPEN_IF_EXISTS, OPEN_SHARE_DENYNONE | OPEN_ACCESS_READWRITE, NULL);
    290         log("DosOpen1 rc %d\n", rc);
    291         if (rc)
    292         {
    293                 unsigned long sid = 0, pid = 0;
    294                 STARTDATA sd;
    295                 char params[CCHMAXPATH * 2] = {0};
    296 
    297                 MemSet(&sd, 0, sizeof(sd));
    298                 sd.Length = sizeof(sd);
    299                 sd.Related = SSF_RELATED_INDEPENDENT;
    300                 sd.FgBg = SSF_FGBG_BACK;
    301                 sd.PgmName = EXECNAME;
    302                 if (pRes->loglevel)
    303                 {
    304                         char level[2];
    305                         level[0] = pRes->loglevel + '0';
    306                         level[1] = 0;
    307                         StrNCat(params, " -d ", sizeof(params) - 1);
    308                         StrNCat(params, level, sizeof(params) - 1);
    309                 }
    310                 if (*pRes->logfile)
    311                 {
    312                         StrNCat(params, " -l ", sizeof(params) - 1);
    313                         StrNCat(params, pRes->logfile, sizeof(params) - 1);
    314                 }
    315                 log("params <%s>\n", params);
    316                 sd.PgmInputs = *params ? params : NULL;
    317                 sd.SessionType = SSF_TYPE_WINDOWABLEVIO;
    318                 rc = DosStartSession(&sd, &sid, &pid);
    319                 log("smbcd startsession pid %d sid %d rc %d\n", pid, sid, rc);
    320                 if (rc == ERROR_SMG_INVALID_CALL)
    321                 {
    322                         // ndfs started ndctl detached, so we have to use dosexecpgm
    323                         char failed[CCHMAXPATH + 1] = {0};
    324                         RESULTCODES res = {0};
    325                         char * p = params;
    326                         StrCpy(p, EXECNAME);
    327                         p += StrLen(p) + 1;
    328                         if (*pRes->logfile)
    329                         {
    330                                 StrCpy(p, "-l ");
    331                                 StrNCat(p, pRes->logfile, sizeof(params) - (p - (char *)params));
    332                                 p += StrLen(p) + 1;
    333                                 if (pRes->loglevel)
    334                                 {
    335                                         char level[2];
    336                                         level[0] = pRes->loglevel + '0';
    337                                         level[1] = 0;
    338                                         StrCpy(p, "-d ");
    339                                         StrNCat(p, level, sizeof(params) - (p - (char *)params));
    340                                         p += StrLen(p) + 1;
    341                                 }
    342                         }
    343                         else
    344                         {
    345                                 StrCpy(p, "-q");
    346                                 p += StrLen(p) + 1;
    347                         }
    348                         *p = 0;         
    349                         rc = DosExecPgm(failed, sizeof(failed), EXEC_BACKGROUND, params, NULL, &res, EXECNAME);
    350                         log("smbcd DosExecPgm codeTerminate %d codeResult %d rc %d\n", res.codeTerminate, res.codeResult, rc);
    351                 }
    352                 if (!rc)
    353                 {
    354                         DosSleep(500);
    355                         rc = DosOpen(PIPENAME, &pipe, &action, 0, 0, OPEN_ACTION_OPEN_IF_EXISTS, OPEN_SHARE_DENYNONE | OPEN_ACCESS_READWRITE, NULL);
    356                         log("DosOpen2 rc %d\n", rc);
    357                 }
    358         }
    359         if (!rc)
    360         {
    361                 if (ppipe)
    362                 {
    363                         *ppipe = pipe;
    364                 }
    365                 else
    366                 {
    367                         DosClose(pipe);
    368                 }
    369         }
    370         return rc;
    371 }
    372 
    373256
    374257void getfindinfo(Connection * pConn, FILEFINDBUF3 * stat, smbwrp_fileinfo * finfo)
    … …  
    385268        if (!*name)
    386269        {
    387                 name = pConn->srv.share_name;
     270                name = pConn->pRes->srv.share_name;
    388271        }
    389272        StrNCpy(stat->achName, name, CCHMAXPATHCOMP - 1);
    … …  
    413296        if (!*name)
    414297        {
    415                 name = pConn->srv.share_name;
     298                name = pConn->pRes->srv.share_name;
    416299        }
    417300        if (mask && (!ph->fsphAttrMatch(ulAttribute, finfo->attr & 0x37) || !ph->fsphWildMatch(mask, name, ND_IGNORE_CASE)))
    … …  
    500383 * [filename][;name=filename]
    501384 */
    502 int initResource (Resource *pRes)
     385int initResource (Resource *pRes, NDPROPERTYHANDLE properties)
    503386{
    504387        int rc = NO_ERROR;
    505388        unsigned long t;
    506389        const unsigned char * q = NULL;
    507         HPIPE pipe;
    508390        int defaultPassword = 1;
    509391
    510         pRes->memlen = 1 << 18;
    511392        pRes->rootlevel = 0;
    512393        *pRes->logfile = 0;
    513394        pRes->loglevel = 0;
    514395        pRes->easupport = 1;
     396#ifdef HAVE_KRB5_H
     397        pRes->krb5support = 1;
     398#else
     399        pRes->krb5support = 0;
     400#endif
    515401
    516402        t = 0, q = NULL;
    517         rc = ph->fsphQueryStringProperty (pRes->properties, "WORKGROUP", &q, &t);
     403        rc = ph->fsphQueryStringProperty (properties, "WORKGROUP", &q, &t);
    518404        if (!rc && t && *q)
    519405        {
    … …  
    523409
    524410        t = 0, q = NULL;
    525         rc = ph->fsphQueryStringProperty (pRes->properties, "SERVER", &q, &t);
     411        rc = ph->fsphQueryStringProperty (properties, "SERVER", &q, &t);
    526412        if (!rc && t && *q)
    527413        {
    … …  
    531417
    532418        t = 0, q = NULL;
    533         rc = ph->fsphQueryStringProperty (pRes->properties, "SHARE", &q, &t);
     419        rc = ph->fsphQueryStringProperty (properties, "SHARE", &q, &t);
    534420        if (!rc && t && *q)
    535421        {
    … …  
    539425
    540426        t = 0, q = NULL;
    541         rc = ph->fsphQueryStringProperty (pRes->properties, "USER", &q, &t);
     427        rc = ph->fsphQueryStringProperty (properties, "USER", &q, &t);
    542428        if (!rc && t && *q)
    543429        {
    … …  
    546432
    547433        t = 0, q = NULL;
    548         rc = ph->fsphQueryStringProperty (pRes->properties, "PASSWORD", &q, &t);
     434        rc = ph->fsphQueryStringProperty (properties, "PASSWORD", &q, &t);
    549435        if (!rc && t && *q)
    550436        {
    … …  
    554440
    555441        t = 0, q = NULL;
    556         rc = ph->fsphQueryStringProperty (pRes->properties, "SPASSWORD", &q, &t);
     442        rc = ph->fsphQueryStringProperty (properties, "SPASSWORD", &q, &t);
    557443        if (   rc == NO_ERROR
    558444            && *q != '\0'
    … …  
    569455       
    570456                /* clear the plain password */
    571                 ph->fsphSetProperty (pRes->properties, "PASSWORD", "");
     457                ph->fsphSetProperty (properties, "PASSWORD", "");
    572458            }
    573459        }
    … …  
    577463            encryptPassword (pRes->srv.password, c);
    578464       
    579             ph->fsphSetProperty (pRes->properties, "SPASSWORD", c);
     465            ph->fsphSetProperty (properties, "SPASSWORD", c);
    580466       
    581467            // clear the plain password
    582             ph->fsphSetProperty (pRes->properties, "PASSWORD", "");
     468            ph->fsphSetProperty (properties, "PASSWORD", "");
    583469        }
    584470
    585471        t = 0, q = NULL;
    586         rc = ph->fsphQueryStringProperty (pRes->properties, "MASTER", &q, &t);
     472        rc = ph->fsphQueryStringProperty (properties, "MASTER", &q, &t);
    587473        if (!rc && t && *q)
    588474        {
    … …  
    591477
    592478        t = 0, q = NULL;
    593         rc = ph->fsphQueryStringProperty (pRes->properties, "LOGFILE", &q, &t);
     479        rc = ph->fsphQueryStringProperty (properties, "LOGFILE", &q, &t);
    594480        if (!rc && t && *q)
    595481        {
    … …  
    598484
    599485        t = 0;
    600         rc = ph->fsphQueryUlongProperty (pRes->properties, "LOGLEVEL", &t);
     486        rc = ph->fsphQueryUlongProperty (properties, "LOGLEVEL", &t);
    601487        if (!rc)
    602488        {
    … …  
    610496
    611497        t = 0;
    612         rc = ph->fsphQueryUlongProperty (pRes->properties, "MASTERTYPE", &t);
     498        rc = ph->fsphQueryUlongProperty (properties, "MASTERTYPE", &t);
    613499        if (!rc)
    614500        {
    … …  
    624510
    625511        t = 0;
    626         rc = ph->fsphQueryUlongProperty (pRes->properties, "EASUPPORT", &t);
     512        rc = ph->fsphQueryUlongProperty (properties, "EASUPPORT", &t);
    627513        if (!rc)
    628514        {
    … …  
    637523        }
    638524
     525#if 0
    639526        t = 0;
    640         rc = ph->fsphQueryUlongProperty (pRes->properties, "MEMLEN", &t);
     527        rc = ph->fsphQueryUlongProperty (properties, "MEMLEN", &t);
    641528        if (!rc)
    642529        {
    … …  
    650537                }
    651538        }
    652 
    653         return rc;
    654 }
    655 
    656 int checkconnection(Connection * pConn)
    657 {
    658         int rc = NO_ERROR;
    659         unsigned long action;
    660         smb_request req = {0};
    661         smb_response resp = {0};
    662         char* mem;
    663 
    664         if (!pConn)
    665         {
    666                 return ERROR_INVALID_PARAMETER;
    667         }
    668         log("checkconnection pconnrc %d pipe %d\n", pConn->rc, pConn->pipe);
    669         // YD this code need probably to be removed (reworked), since DosQueryNPHState,
    670         // DosQueryNPipeInfo, DosPeekNPipe, DosResetBuffer, are all returning
    671         // NO_ERROR even if the other pipe end is closed (smbcd crash).
    672         //
    673         // YD TODO probably checkconnection() call can be removed since we
    674         // detect broken pipes inside _DosTransactNPipe
    675         if (!pConn->rc)
    676         {
    677                 unsigned long state = 0;
    678                 rc = DosQueryNPHState(pConn->pipe, &state);
    679                 log("DosQueryNPHstate(pConn->pipe) = %d (%08x)\n", pConn->rc, pConn->pipe, rc, state);
    680                 if (!rc)
    681                 {
    682                         return pConn->rc;
    683                 }
    684         }
    685         // there were error on pipe, reopen it and restore connection
    686         if (pConn->pipe)
    687         {
    688                 DosClose(pConn->pipe);
    689                 pConn->pipe = 0;
    690         }
    691         rc = openpipe(pConn->pRes, &pConn->pipe);
    692         if (rc)
    693         {
    694                 log("checkconnection openpipe %d\n", rc);
    695                 pConn->pipe = 0;
    696                 DosSleep(1000);
    697                 return ERROR_PIPE_NOT_CONNECTED;
    698         }
    699 
    700         // if we are reconnecting pipe because of a broken pipe, we
    701         // need to save shared memory content to allow operation retry
    702         mem = malloc( pConn->pRes->memlen);
    703         if (mem)
    704                 memcpy( mem, pConn->mem, pConn->pRes->memlen);
    705 
    706         // reinit connection 
    707         do {
    708                 req.request = SMBREQ_INIT;
    709                 req.param = (char *)0xFFFFFFFF;
    710                 pConn->rc = DosTransactNPipe(pConn->pipe, &req, sizeof(req), &resp, sizeof(resp), &action);
    711                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    712                 {
    713                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    714                         break;
    715                 }
    716                 pConn->clientpid = resp.value & 0xFFFF;
    717                 // client daemon pid changed
    718                 pConn->rc = DosGiveSharedMem(pConn->mem, pConn->clientpid, PAG_READ | PAG_WRITE);
    719                 if (pConn->rc)
    720                 {
    721                         rc = pConn->rc;
    722                         break;
    723                 }
    724                 MemCpy(pConn->mem, &pConn->srv, sizeof(pConn->srv));
    725 
    726                 req.request = SMBREQ_CONNECT;
    727                 req.param = pConn->mem;
    728                 req.paramlen = sizeof(pConn->srv);
    729                 req.length = req.paramlen;
    730 
    731                 pConn->rc = DosTransactNPipe(pConn->pipe, &req, sizeof(req), &resp, sizeof(resp), &action);
    732                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    733                 {
    734                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    735                         break;
    736                 }
    737                 MemCpy(&pConn->srv, pConn->mem, sizeof(pConn->srv));
    738 
    739                 rc = NO_ERROR;
    740         } while (0);
    741 
    742         // if we are reconnecting pipe because of a broken pipe, we
    743         // need to restore shared memory content to allow operation retry
    744         if (mem) {
    745                 memcpy( pConn->mem, mem, pConn->pRes->memlen);
    746                 free( mem);
    747         }
    748 
    749         if (pConn->rc && pConn->pipe)
    750         {
    751                 DosClose(pConn->pipe);
    752                 pConn->pipe = 0;
    753         }
    754         return rc;
    755 }
    756 
    757 /*
    758  * YD Since DosQueryNPHState,
    759  * DosQueryNPipeInfo, DosPeekNPipe, DosResetBuffer, are all returning
    760  * NO_ERROR even if the other pipe end is closed (smbcd crash),
    761  * we can detect broken pipes only when writing/reading from the pipe.
    762 */
    763 ULONG APIENTRY _DosTransactNPipe(Connection *pConn, PVOID pOutbuf, ULONG ulOutbufLength,
    764     PVOID pInbuf, ULONG ulInbufLength, PULONG pulBytesRead)
    765 {
    766         APIRET rc;
    767 
    768         // try first
    769         rc = DosTransactNPipe(pConn->pipe, pOutbuf, ulOutbufLength, pInbuf, ulInbufLength, pulBytesRead);
    770         if (rc != ERROR_BROKEN_PIPE)
    771                 return rc;
    772         // client daemon closed, force open connection again
    773         pConn->rc = rc;
    774         checkconnection( pConn);
    775         // issue command again
    776         rc = DosTransactNPipe(pConn->pipe, pOutbuf, ulOutbufLength, pInbuf, ulInbufLength, pulBytesRead);
     539#endif
     540
    777541        return rc;
    778542}
    … …  
    810574                return NO_ERROR;
    811575        }
     576
    812577        rootlevel = pRes->rootlevel;
    813578        if (*path == '\\') path++;
     579#if 0 // FIXME
    814580        if (rootlevel < 3)
    815581        {
    … …  
    902668                }
    903669        }
     670#endif
    904671        StrCpy(result, "\\");
    905672        StrNCat(result, path, CCHMAXPATH);
    906         return rc;
    907 }
    908 
    909 int APIENTRY NdpFreeResource (HRESOURCE resource)
    910 {
    911         Resource *pRes = (Resource *)resource;
    912         MemSet(&pRes->srv, 0, sizeof(pRes->srv));
    913         DosFreeMem(pRes);
    914         log("NdpFreeResource %d\n", NO_ERROR);
    915         return NO_ERROR;
    916 }
     673
     674        return rc;
     675}
     676
    917677
    918678// -------------------------------------------------------------
    … …  
    923683        int rc;
    924684        unsigned long action;
    925         smb_request req = {0};
    926         smb_response resp = {0};
    927         Connection Conn = {0};
     685        //smbwrp_server srv;
     686        cli_state* cli;
     687        smbwrp_file file;
    928688
    929689        debug_printf("checkMountResource in tid#%d\n", _gettid());
    930 
    931         // open the pipe
    932         Conn.pRes = pRes;
    933         Conn.file.fd = -1;
    934         debug_printf("checkMountResource open pipe\n");
    935         rc = openpipe(pRes, &Conn.pipe);
     690        rc = smbwrp_connect( pRes, &cli);
    936691        if (rc)
    937         {
    938             debug_printf("checkMountResource open pipe failed rc=%d\n", rc);
    939             return rc;
    940         }
    941 
    942         // init, get client pid
    943         debug_printf("checkMountResource send INIT for '%s'\n", pRes->srv.share_name);
    944         req.request = SMBREQ_INIT;
    945         req.param = (char *)0xFFFFFFFF;
    946         rc = _DosTransactNPipe(&Conn, &req, sizeof(req), &resp, sizeof(resp), &action);
    947         if (rc || action < sizeof(resp) || resp.rc)
    948         {
    949             debug_printf("checkMountResource INIT failed rc=%d\n", rc);
    950             // close pipe
    951             DosClose( Conn.pipe);
    952             return rc;
    953         }
    954         Conn.clientpid = resp.value & 0xFFFF;
    955 
    956         // allocate shared memory
    957         rc = DosAllocSharedMem((PPVOID)&Conn.mem, NULL, pRes->memlen, PAG_COMMIT | PAG_READ | PAG_WRITE | OBJ_GIVEABLE | pRes->objany);
    958         if (rc)
    959         {
    960             debug_printf("checkMountResource DosAllocSharedMem failed rc=%d\n", rc);
    961             // close pipe
    962             DosClose( Conn.pipe);
    963             return rc;
    964         }
    965         rc = DosGiveSharedMem( Conn.mem, Conn.clientpid, PAG_READ | PAG_WRITE);
    966         if (!rc)
    967         {
    968             // open connection with samba server, just to check share type
    969             debug_printf("checkMountResource send CONNECT\n");
    970             MemCpy( Conn.mem, &pRes->srv, sizeof(pRes->srv));
    971             req.request = SMBREQ_CONNECT;
    972             req.param = Conn.mem;
    973             req.paramlen = sizeof( Conn.srv);
    974             req.length = req.paramlen;
    975             rc = _DosTransactNPipe( &Conn, &req, sizeof(req), &resp, sizeof(resp), &action);
    976             if (rc || action < sizeof(resp) || resp.rc)
    977             {
    978                 debug_printf("checkMountResource SMBREQ_CONNECT failed rc=%d, resp.rc=%d\n", rc, resp.rc);
    979                 rc = (rc == NO_ERROR ? resp.rc : rc);
    980             }
    981             // no more data, close connection   
    982             req.request = SMBREQ_DISCONNECT;
    983             req.param = Conn.mem;
    984             req.length = 0;
    985             req.paramlen = 0;
    986             _DosTransactNPipe( &Conn, &req, sizeof(req), &resp, sizeof(resp), &action);
    987         }
    988 
    989         // free memory
    990         DosFreeMem( Conn.mem);
    991         // close pipe
    992         DosClose( Conn.pipe);
     692            rc = (rc == 7 ? ERROR_BAD_DEV_TYPE : ERROR_ACCESS_DENIED);
     693        smbwrp_disconnect( pRes, cli);
    993694
    994695        return rc;
    … …  
    1003704        log("NdpMountResource in\n");
    1004705
     706        // init code
     707        smbwrp_init();
     708
    1005709        /* since samba plugin support only 1 type of resources we do not need */
    1006710        /* to check what the found type really is */
    1007         rc = DosAllocMem((void **)&pRes, sizeof(Resource), PAG_COMMIT | PAG_READ | PAG_WRITE | objany);
    1008         if (rc == ERROR_INVALID_PARAMETER)
    1009         {
    1010                 objany = 0;
    1011                 rc = DosAllocMem((void **)&pRes, sizeof(Resource), PAG_COMMIT | PAG_READ | PAG_WRITE);
    1012         }
    1013         if (!rc && pRes == NULL)
     711        pRes = malloc( sizeof(Resource));
     712        if (pRes == NULL)
    1014713        {
    1015714                rc = ERROR_NOT_ENOUGH_MEMORY;
    1016         }
    1017         if (!rc)
     715        } 
     716        else
    1018717        {
    1019718                MemSet(pRes, 0, sizeof(Resource));
    1020                 pRes->properties = properties;
    1021                 pRes->objany = objany;
     719                //pRes->objany = objany;
    1022720                // parse init string
    1023                 rc = initResource (pRes);
     721                rc = initResource (pRes, properties);
    1024722                // try to connect to resource (check type) only if thread!=1, so ndctl startup
    1025723                // is not slowed down by network connections.
    … …  
    1035733                else
    1036734                {
    1037                         NdpFreeResource((HRESOURCE)pRes);
     735                        free(pRes);
    1038736                }
    1039737        }
    … …  
    1044742// -------------------------------------------------------------
    1045743
    1046 int APIENTRY NdpCreateConnection (HRESOURCE resource, HCONNECTION *pconn)
    1047 {
    1048         int rc;
    1049         Resource * pRes = (Resource *)resource;
    1050         unsigned long action;
    1051         smb_request req = {0};
    1052         smb_response resp = {0};
    1053         Connection *pConn = NULL;
    1054 
    1055         log("NdpCreateConnection in\n");
    1056 
    1057         rc = DosAllocMem((void **)&pConn, sizeof(Connection), PAG_COMMIT | PAG_READ | PAG_WRITE | pRes->objany);
    1058         if (!rc && pConn == NULL)
    1059         {
    1060                 rc =  ERROR_NOT_ENOUGH_MEMORY;
    1061         }
    1062         if (rc)
    1063         {
    1064                 log("NdpCreateConnection ERROR_NOT_ENOUGH_MEMORY %d\n", rc);
    1065                 return rc;
    1066         }
    1067         MemSet(pConn, 0, sizeof(Connection));
    1068         pConn->pRes = pRes;
    1069         pConn->file.fd = -1;
    1070 
    1071         do {
    1072                 log("NdpCreateConnection open pipe\n");
    1073                 rc = openpipe(pRes, &pConn->pipe);
    1074                 if (rc)
    1075                 {
    1076                         pConn->pipe = 0;
    1077                         break;
    1078                 }
    1079 
    1080                 log("NdpCreateConnection send INIT\n");
    1081                 req.request = SMBREQ_INIT;
    1082                 req.param = (char *)0xFFFFFFFF;
    1083                 rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    1084                 if (rc || action < sizeof(resp) || resp.rc)
    1085                 {
    1086                         return rc ? rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    1087                 }
    1088                 pConn->clientpid = resp.value & 0xFFFF;
    1089 
    1090                 rc = DosAllocSharedMem((PPVOID)&pConn->mem, NULL, pRes->memlen, PAG_COMMIT | PAG_READ | PAG_WRITE | OBJ_GIVEABLE | pRes->objany);
    1091                 if (rc)
    1092                 {
    1093                         break;
    1094                 }
    1095                 rc = DosGiveSharedMem(pConn->mem, pConn->clientpid, PAG_READ | PAG_WRITE);
    1096                 if (rc)
    1097                 {
    1098                         break;
    1099                 }
    1100 
    1101                 log("NdpCreateConnection send CONNECT\n");
    1102                 MemCpy(pConn->mem, &pRes->srv, sizeof(pRes->srv));
    1103                 req.request = SMBREQ_CONNECT;
    1104                 req.param = pConn->mem;
    1105                 req.paramlen = sizeof(pConn->srv);
    1106                 req.length = req.paramlen;
    1107 
    1108                 rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    1109                 if (rc || action < sizeof(resp) || resp.rc)
    1110                 {
    1111                         rc = rc ? rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    1112                 }
    1113                 else
    1114                 {
    1115                         MemCpy(&pConn->srv, pConn->mem, sizeof(pConn->srv));
    1116                 }
    1117         } while (0);
    1118         if (rc)
    1119         {
    1120                 if (pConn->mem)
    1121                 {
    1122                         DosFreeMem(pConn->mem);
    1123                 }
    1124                 if (pConn->pipe)
    1125                 {
    1126                         DosClose(pConn->pipe);
    1127                 }
    1128                 MemSet(pConn, 0, sizeof(*pConn));
    1129                 DosFreeMem(pConn);
    1130                 pConn = NULL;
    1131         }
    1132 
    1133         *pconn = (HCONNECTION)pConn;
    1134         log("NdpCreateConnection %d %d\n", rc, resp.rc);
    1135         return rc;
     744int APIENTRY NdpFreeResource (HRESOURCE resource)
     745{
     746        Resource *pRes = (Resource *)resource;
     747        MemSet(&pRes->srv, 0, sizeof(pRes->srv));
     748        free(pRes);
     749        log("NdpFreeResource %d\n", NO_ERROR);
     750        return NO_ERROR;
    1136751}
    1137752
    1138753// -------------------------------------------------------------
    1139 
    1140 int APIENTRY NdpFreeConnection (HCONNECTION conn)
    1141 {
    1142         Connection *pConn = (Connection *)conn;
    1143         Resource *pRes = pConn->pRes;
    1144 
    1145         log("NdpFreeConnection in\n");
    1146         if (pConn->mem)
    1147         {
    1148                 smb_request req = {0};
    1149                 smb_response resp = {0};
    1150                 unsigned long action;
    1151                 if (pConn->file.fd >= 0)
    1152                 {
    1153                         MemCpy(pConn->mem, &pConn->file, sizeof(pConn->file));
    1154                         req.request = SMBREQ_CLOSE;
    1155                         req.param = pConn->mem;
    1156                         req.length = sizeof(pConn->file);
    1157                         req.paramlen = sizeof(pConn->file);
    1158 
    1159                         _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    1160                         pConn->file.fd = -1;
    1161                 }
    1162 
    1163                 req.request = SMBREQ_DISCONNECT;
    1164                 req.param = pConn->mem;
    1165                 req.length = 0;
    1166                 req.paramlen = 0;
    1167 
    1168                 _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    1169 
    1170                 DosFreeMem(pConn->mem);
    1171                 DosClose(pConn->pipe);
    1172                 MemSet(pConn, 0, sizeof(*pConn));
    1173         }
    1174 
    1175         DosFreeMem(pConn);
    1176         log("NdpFreeConnection %d\n", NO_ERROR);
    1177         return NO_ERROR;
    1178 }
    1179754
    1180755int APIENTRY NdpRsrcCompare (HRESOURCE resource, HRESOURCE resource2)
    … …  
    1185760
    1186761        log("NdpRsrcCompare in\n");
    1187 
    1188762        if (ph->fsphStrICmp(pRes->srv.server_name, pRes2->srv.server_name) == 0
    1189763                && ph->fsphStrICmp(pRes->srv.share_name, pRes2->srv.share_name) == 0
    … …  
    1258832int APIENTRY NdpRsrcQueryFSAllocate (HRESOURCE resource, NDFSALLOCATE *pfsa)
    1259833{
     834        Resource *pRes = (Resource *)resource;
    1260835        int rc = NO_ERROR, rc1;
    1261 
    1262         Connection *pConn = 0;
    1263         smb_request req = {0};
    1264         smb_response resp = {0};
    1265836        unsigned long action = 0;
     837        smbwrp_file file;
     838        cli_state* cli;
     839        FSALLOCATE fsa;
    1266840
    1267841        log("NdpRsrcQueryFSAllocate %08x\n", pfsa);
    … …  
    1272846        }
    1273847
    1274 
    1275         rc = NdpCreateConnection (resource, (HCONNECTION *)&pConn);
     848        debug_printf("checkMountResource in tid#%d\n", _gettid());
     849        rc = smbwrp_connect( pRes, &cli);
    1276850        if (rc)
    1277851        {
    1278                 log("NdpCreateConnection failed rc=%d\n", rc); 
     852            log("NdpCreateConnection failed rc=%d\n", rc);     
     853            pfsa->cSectorUnit = 1;
     854            pfsa->cUnit = 123456;
     855            pfsa->cUnitAvail = 123456;
     856            pfsa->cbSector = 2048;
     857            return rc;
     858        }
     859
     860        rc = smbwrp_dskattr( cli, &fsa);
     861        if (rc)
     862        {
    1279863                pfsa->cSectorUnit = 1;
    1280864                pfsa->cUnit = 123456;
    1281865                pfsa->cUnitAvail = 123456;
    1282866                pfsa->cbSector = 2048;
     867                //rc = rc ? rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
     868        }
     869        else
     870        {
     871                pfsa->cSectorUnit = fsa.cSectorUnit;
     872                pfsa->cUnit = fsa.cUnit;
     873                pfsa->cUnitAvail = fsa.cUnitAvail;
     874                pfsa->cbSector = fsa.cbSector;
     875        }
     876
     877        smbwrp_disconnect( pRes, cli);
     878
     879        log("NdpRsrcQueryFSAllocate %d/%d (cUnit = %d/cUnitAvail = %d/cbSector = %d)\n", rc, rc1, pfsa->cUnit, pfsa->cUnitAvail, pfsa->cbSector);
     880        return rc;
     881}
     882
     883// -------------------------------------------------------------
     884
     885int APIENTRY NdpCreateConnection (HRESOURCE resource, HCONNECTION *pconn)
     886{
     887        int rc = 0;
     888        Resource * pRes = (Resource *)resource;
     889        unsigned long action;
     890        Connection *pConn = NULL;
     891
     892        log("NdpCreateConnection in\n");
     893
     894        pConn = malloc( sizeof(Connection));
     895        if (pConn == NULL)
     896        {
     897                rc =  ERROR_NOT_ENOUGH_MEMORY;
     898        }
     899        if (rc)
     900        {
     901                log("NdpCreateConnection ERROR_NOT_ENOUGH_MEMORY %d\n", rc);
    1283902                return rc;
    1284903        }
    1285 
    1286         MemSet(pConn->mem, 0, sizeof(FSALLOCATE));
    1287         req.request = SMBREQ_DSKATTR;
    1288         req.param = pConn->mem;
    1289         req.paramlen = sizeof(FSALLOCATE);
    1290         req.length = req.paramlen;
    1291 
    1292         rc = DosTransactNPipe( pConn->pipe, &req, sizeof(req), &resp, sizeof(resp), &action);
    1293         if (rc || action < sizeof(resp) || resp.rc)
    1294         {
    1295                 pfsa->cSectorUnit = 1;
    1296                 pfsa->cUnit = 123456;
    1297                 pfsa->cUnitAvail = 123456;
    1298                 pfsa->cbSector = 2048;
    1299                 rc = rc ? rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    1300         }
    1301         else
    1302         {
    1303                 FSALLOCATE * fsa = (FSALLOCATE *)pConn->mem;
    1304                 pfsa->cSectorUnit = fsa->cSectorUnit;
    1305                 pfsa->cUnit = fsa->cUnit;
    1306                 pfsa->cUnitAvail = fsa->cUnitAvail;
    1307                 pfsa->cbSector = fsa->cbSector;
    1308         }
    1309 
    1310         rc1 = NdpFreeConnection((HCONNECTION)pConn);
    1311 
    1312         log("NdpRsrcQueryFSAllocate %d/%d/%d (cUnit = %d/cUnitAvail = %d/cbSector = %d)\n", rc, resp.rc, rc1, pfsa->cUnit, pfsa->cUnitAvail, pfsa->cbSector);
    1313         return rc;
    1314 }
    1315 
    1316 int APIENTRY NdpFindStart (HCONNECTION conn, void *plist, NDFILEINFOL *pfiparent, char *szPath, ULONG ulAttribute)
    1317 {
    1318         Connection *pConn = (Connection *)conn;
    1319         Resource *pRes = pConn->pRes;
    1320         int rc = NO_ERROR, count = 0;
    1321         unsigned long action;
    1322         smb_request req = {0};
    1323         smb_response resp = {0};
    1324         char *mask = "*";
    1325         char dir[CCHMAXPATH+1] = {0};
    1326         char path[CCHMAXPATH+1] = {0};
    1327         char fullname[CCHMAXPATH+1] = {0};
    1328         smbwrp_fileinfo * data;
    1329         NDPATHELEMENT *pel = ph->fsphNameElem(0);
    1330 
    1331         debug_printf("NdpFindStart in\n");
    1332         do
    1333         {
    1334                 rc = checkconnection(pConn);
    1335                 if (rc)
    1336                 {
    1337                         break;
    1338                 }
    1339 
    1340                 StrNCpy(dir, szPath, sizeof(dir) - 1);
    1341                 if (pel)
    1342                 {
    1343                         mask = pel->name;
    1344                         dir[StrLen(szPath) - pel->length] = 0;
    1345                 }
    1346                 action = StrLen(dir) - 1;
    1347                 if (dir[action] == '\\')
    1348                 {
    1349                         dir[action] = 0;
    1350                 }
    1351                 rc = pathparser(pRes, pConn, dir, path);
    1352                 if (rc)
    1353                 {
    1354                         break;
    1355                 }
    1356                 action = StrLen(path) - 1;
    1357                 if (path[action] != '\\')
    1358                 {
    1359                         StrNCat(path, "\\", sizeof(path) - 1);
    1360                 }
    1361                 StrCpy(dir, path);
    1362                 StrNCat(path, mask, sizeof(path) - 1);
    1363 
    1364                 MemCpy(pConn->mem, &pConn->srv, sizeof(pConn->srv));
    1365                 StrCpy(pConn->mem + sizeof(pConn->srv), path);
    1366                 req.request = SMBREQ_FILELIST;
    1367                 req.param = pConn->mem;
    1368                 req.paramlen = sizeof(pConn->srv) + CCHMAXPATH + 1;
    1369                 req.length = pRes->memlen;
    1370                 data = (smbwrp_fileinfo *)(pConn->mem + sizeof(pConn->srv) + CCHMAXPATH + 1);
    1371 
    1372                 do {
    1373                         int i;
    1374                         pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    1375                         if (pConn->rc || action < sizeof(resp)
    1376                                 || (resp.rc && resp.rc != ERROR_MORE_DATA))
    1377                         {
    1378                                 rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    1379                                 break;
    1380                         }
    1381 log("NdpFindStart %d %d %d\n", pConn->rc, resp.rc, resp.length / sizeof(smbwrp_fileinfo));
    1382                         if (ifL)
    1383                         {
    1384                                 for (i = 0; i < resp.length / sizeof(smbwrp_fileinfo); i++)
    1385                                 {
    1386                                         smbwrp_fileinfo * finfo = data + i;
    1387 log("NdpFindStart found <%s> %d\n", finfo->fname, finfo->easize);
    1388                                         StrCpy(fullname, dir);
    1389                                         StrCat(fullname, finfo->fname);
    1390                                         StrCpy(finfo->fname, fullname);
    1391                                         count += getfindinfoL(pConn, plist, finfo, ulAttribute, mask);
    1392                                 }
    1393                         }
    1394                         else
    1395                         {
    1396                                 FILEFINDBUF3 buf = {0};
    1397                                 for (i = 0; i < resp.length / sizeof(smbwrp_fileinfo); i++)
    1398                                 {
    1399                                         smbwrp_fileinfo * finfo = data + i;
    1400                                         getfindinfo(pConn, &buf, finfo);
    1401                
    1402                                         if (ph->fsphAttrMatch(ulAttribute, buf.attrFile)
    1403                                                 && ph->fsphWildMatch(mask, buf.achName, ND_IGNORE_CASE))
    1404                                         {
    1405                                                 StrCpy(fullname, dir);
    1406                                                 StrCat(fullname, finfo->fname);
    1407                                                 StrCpy(finfo->fname, fullname);
    1408                                                 ph->fsphAddFileFind32(plist, &buf, finfo, sizeof(*finfo), 0);
    1409                                                 count++;
    1410                                         }
    1411                                 }
    1412                         }
    1413                 } while (resp.rc == ERROR_MORE_DATA);
    1414         } while (0);
    1415 
    1416         log("NdpFindStart <%s> (%s) cnt %d %d %d\n", szPath, path, count, rc, pConn->rc);
    1417         return rc;
    1418 }
     904        MemSet(pConn, 0, sizeof(Connection));
     905        pConn->pRes = pRes;
     906        pConn->file.fd = -1;
     907
     908        log("NdpCreateConnection send CONNECT\n");
     909        rc = smbwrp_connect( pRes, &pConn->cli);
     910        if (rc)
     911        {
     912                free(pConn);
     913                pConn = NULL;
     914        }
     915
     916        *pconn = (HCONNECTION)pConn;
     917        log("NdpCreateConnection %d %d\n", rc, resp.rc);
     918        return rc;
     919}
     920
     921// -------------------------------------------------------------
     922
     923int APIENTRY NdpFreeConnection (HCONNECTION conn)
     924{
     925        Connection *pConn = (Connection *)conn;
     926        Resource *pRes = pConn->pRes;
     927        int rc;
     928
     929        log("NdpFreeConnection in\n");
     930        if (pConn->file.fd >= 0)
     931        {
     932                rc = smbwrp_close( pConn->cli, &pConn->file);
     933                pConn->file.fd = -1;
     934        }
     935
     936        smbwrp_disconnect( pRes, pConn->cli);
     937
     938        free(pConn);
     939        log("NdpFreeConnection %d\n", NO_ERROR);
     940        return NO_ERROR;
     941}
     942
     943// -------------------------------------------------------------
    1419944
    1420945int APIENTRY NdpQueryPathInfo (HCONNECTION conn, void *plist, char *szPath)
    … …  
    1422947        Connection *pConn = (Connection *)conn;
    1423948        Resource *pRes = pConn->pRes;
    1424         int rc = 0;
    1425         unsigned long action;
    1426         smb_request req = {0};
    1427         smb_response resp = {0};
    1428         smbwrp_fileinfo * finfo = (smbwrp_fileinfo *)pConn->mem;
     949        smbwrp_fileinfo finfo;
     950        int rc = 0;
     951        unsigned long action;
    1429952        char path[CCHMAXPATH+1] = {0};
    1430953        int retry = 0;
    … …  
    1432955        do
    1433956          {
    1434                 debug_printf("NdpQueryInfo in <%s>, retry = %d\n", szPath, retry);
     957                log("NdpQueryPathInfo in <%s>, retry = %d\n", szPath, retry);
    1435958
    1436959                do {
    … …  
    1442965                        }
    1443966
    1444                         rc = checkconnection(pConn);
    1445                         if (rc)
    1446                         {
    1447                                 break;
    1448                         }
    1449 
    1450967                        rc = pathparser(pRes, pConn, szPath, path);
     968                        log("NdpQueryPathInfo pathparser for <%s> rc=%d\n", path, rc);
    1451969                        switch (rc)
    1452970                        {
    … …  
    1468986                                break;
    1469987                        }
    1470                         StrNCpy(finfo->fname, path, sizeof(finfo->fname) - 1);
    1471                         req.request = SMBREQ_GETINFO;
    1472                         req.param = pConn->mem;
    1473                         req.paramlen = sizeof(*finfo);
    1474                         req.length = req.paramlen;
    1475                         pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    1476                         if (pConn->rc || action < sizeof(resp) || resp.rc)
    1477                         {
    1478                                 switch (resp.rc)
     988                        StrNCpy(finfo.fname, path, sizeof(finfo.fname) - 1);
     989                        log("NdpQueryPathInfo smbwrp_getattr for <%s>\n", path);
     990                        rc = smbwrp_getattr( &pRes->srv, pConn->cli, &finfo);
     991                        if (rc)
     992                        {
     993                                switch (rc)
    1479994                                {
    1480995                                        case NO_ERROR :
    … …  
    14861001                                        default :
    14871002                                        {
    1488                                                 resp.rc = ERROR_PATH_NOT_FOUND;
     1003                                                rc = ERROR_PATH_NOT_FOUND;
    14891004                                        }
    14901005                                }
    1491                                 rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
     1006                                rc =rc ? rc : ERROR_INVALID_PARAMETER;
    14921007                        }
    14931008                        else
    14941009                        {
    1495                                 finfo->easize = -1;
    1496                                 if (ifL)
    1497                                 {
    1498                                         getfindinfoL(pConn, plist, finfo, 0, NULL);
    1499                                 }
    1500                                 else
    1501                                 {
    1502                                         int trc;
    1503                                         FILEFINDBUF3 buf = {0};
    1504                                         getfindinfo(pConn, &buf, finfo);
    1505                                         trc = ph->fsphAddFileFind32(plist, &buf, finfo, sizeof(*finfo), 0);
    1506                                         log("NdpQueryInfo got info <%s> attr %08x size %d namelen %d date %lu %lu. Plist 0x%08x rc = %d\n", buf.achName, buf.attrFile, buf.cbFile, buf.cchName, buf.fdateLastWrite, buf.ftimeLastWrite, plist, trc);
    1507                                 }
     1010                                finfo.easize = -1;
     1011                                getfindinfoL(pConn, plist, &finfo, 0, NULL);
    15081012                        }
    15091013                        if (rc == ERROR_FILE_NOT_FOUND)
    15101014                        {
    15111015                                // now try the upper path
    1512                                 char * p = ph->fsphStrChr(finfo->fname, '\\');
    1513                                 if (p && p > finfo->fname)
     1016                                char * p = ph->fsphStrChr(finfo.fname, '\\');
     1017                                if (p && p > finfo.fname)
    15141018                                {
    15151019                                        *p = 0;
    1516                                         rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    1517                                         if (pConn->rc || action < sizeof(resp) || resp.rc)
     1020                                        rc = smbwrp_getattr( &pRes->srv, pConn->cli, &finfo);
     1021                                        if (rc)
    15181022                                        {       
    1519                                                 rc = pConn->rc ? pConn->rc : (resp.rc ? ERROR_PATH_NOT_FOUND : ERROR_INVALID_PARAMETER);
     1023                                                rc = rc ? ERROR_PATH_NOT_FOUND : ERROR_INVALID_PARAMETER;
    15201024                                        }
    15211025                                }
    15221026                        }
    15231027                } while (0);
    1524                 log("NdpQueryInfo <%s> (%s) %d %d\n", szPath, path, rc, pConn->rc);
     1028                log("NdpQueryPathInfo <%s> (%s) %d\n", szPath, path, rc);
    15251029                retry = rc && !retry;
     1030
    15261031        } while (retry);
    15271032       
     1033        return rc;
     1034}
     1035
     1036// -------------------------------------------------------------
     1037
     1038int APIENTRY NdpFindStart (HCONNECTION conn, void *plist, NDFILEINFOL *pfiparent, char *szPath, ULONG ulAttribute)
     1039{
     1040        Connection *pConn = (Connection *)conn;
     1041        Resource *pRes = pConn->pRes;
     1042        int rc = NO_ERROR, count = 0;
     1043        unsigned long action;
     1044        char *mask = "*";
     1045        char dir[CCHMAXPATH+1] = {0};
     1046        char path[CCHMAXPATH+1] = {0};
     1047        smbwrp_fileinfo * data;
     1048        NDPATHELEMENT *pel = ph->fsphNameElem(0);
     1049        filelist_state state;
     1050        char * p;
     1051
     1052        debug_printf("NdpFindStart in\n");
     1053
     1054                StrNCpy(dir, szPath, sizeof(dir) - 1);
     1055                if (pel)
     1056                {
     1057                        mask = pel->name;
     1058                        dir[StrLen(szPath) - pel->length] = 0;
     1059                }
     1060                action = StrLen(dir) - 1;
     1061                if (dir[action] == '\\')
     1062                {
     1063                        dir[action] = 0;
     1064                }
     1065                rc = pathparser(pRes, pConn, dir, path);
     1066                if (rc)
     1067                {
     1068                        return rc;
     1069                }
     1070                action = StrLen(path) - 1;
     1071                if (path[action] != '\\')
     1072                {
     1073                        StrNCat(path, "\\", sizeof(path) - 1);
     1074                }
     1075                StrCpy(dir, path);
     1076                StrNCat(path, mask, sizeof(path) - 1);
     1077
     1078                // this structure will be used by libsmb callbacks, so we store here all we need
     1079                // to fill netdrive structures
     1080                state.pConn = pConn;
     1081                state.plist = plist;
     1082                state.ulAttribute = ulAttribute;
     1083                strcpy( state.dir, dir);
     1084                strcpy( state.dir_mask, mask);
     1085                strcpy( state.mask, path);
     1086                p = getlastslash(state.mask);
     1087                if (p)
     1088                {
     1089                        *(p + 1) = '*';
     1090                        *(p + 2) = 0;
     1091                }
     1092                else
     1093                {
     1094                        strcpy(state.mask, "\\*");
     1095                }
     1096                rc = smbwrp_filelist( &pRes->srv, pConn->cli, &state);
     1097
     1098        log("NdpFindStart <%s> (%s) cnt %d %d\n", szPath, path, count, rc);
     1099
    15281100        return rc;
    15291101}
    … …  
    15591131        int rc = 0;
    15601132        unsigned long action;
    1561         smb_request req = {0};
    1562         smb_response resp = {0};
    1563         smbwrp_fileinfo * finfo = (smbwrp_fileinfo *)pConn->mem;
    15641133        char path[CCHMAXPATH+1] = {0};
    1565 
    1566         debug_printf("NdpSetPathInfo in\n");
     1134        smbwrp_fileinfo finfo;
     1135
     1136        debug_printf("NdpSetPathInfo in FIXME\n");
     1137
    15671138        do {
    1568                 rc = checkconnection(pConn);
    1569                 if (rc)
    1570                 {
    1571                         break;
    1572                 }
    1573 
    15741139                rc = pathparser(pRes, pConn, szPathName, path);
    15751140                if (rc)
    … …  
    15781143                }
    15791144
    1580                 MemSet(finfo, 0, sizeof(*finfo));
    1581 
    1582                 StrNCpy(finfo->fname, path, sizeof(finfo->fname) - 1);
    1583                 fsphDosDateToUnixTime(pfi->stat.fdateLastWrite, pfi->stat.ftimeLastWrite, &(finfo->mtime));
    1584                 if (ifL)
    1585                 {
    1586                         finfo->attr = pfi->stat.attrFile & 0x37;
    1587                 }
    1588                 else
    1589                 {
    1590                         FILESTATUS3 * stat = (FILESTATUS3 *)&(pfi->stat);
    1591                         finfo->attr = stat->attrFile & 0x37;
    1592                 }
    1593                 req.request = SMBREQ_SETINFO;
    1594                 req.param = pConn->mem;
    1595                 req.paramlen = sizeof(*finfo);
    1596                 req.length = req.paramlen;
    1597                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    1598                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    1599                 {
    1600                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    1601                 }
     1145                MemSet(&finfo, 0, sizeof(finfo));
     1146
     1147                StrNCpy(finfo.fname, path, sizeof(finfo.fname) - 1);
     1148                fsphDosDateToUnixTime(pfi->stat.fdateLastWrite, pfi->stat.ftimeLastWrite, &(finfo.mtime));
     1149                finfo.attr = pfi->stat.attrFile & 0x37;
     1150                rc = smbwrp_setattr(pConn->cli, &finfo);
    16021151        } while (0);
    1603         log("NdpSetPathInfo <%s> (%s) %d %d\n", szPathName, path, rc, pConn->rc);
     1152        log("NdpSetPathInfo <%s> (%s) %d\n", szPathName, path, rc);
     1153
    16041154        return rc;
    16051155}
    … …  
    16701220        int rc = 0;
    16711221        unsigned long action;
    1672         smb_request req = {0};
    1673         smb_response resp = {0};
    16741222        char * path = NULL;
    16751223        FEALIST * pFEASrc;
    16761224        NDDATABUF fdata = {0};
    16771225        smbwrp_fileinfo *finfo;
     1226        char    pBuffer[64*1024];
    16781227
    16791228        if (!pfi || !pfi->pszName || !pFEAList)
    … …  
    16961245
    16971246        log("NdpEAQuery in <%s> %08x %d\n", path, pGEAList, pGEAList ? pGEAList->cbList : 0);
     1247
    16981248        do {
    1699                 rc = checkconnection(pConn);
     1249                rc = smbwrp_listea( pConn->cli, path, pBuffer, sizeof( pBuffer));
     1250                pFEASrc = (FEALIST*) pBuffer;
    17001251                if (rc)
    17011252                {
    1702                         break;
    1703                 }
    1704 
    1705                 StrNCpy(pConn->mem, path, CCHMAXPATH);
    1706                 req.request = SMBREQ_LISTEA;
    1707                 req.param = pConn->mem;
    1708                 req.paramlen = CCHMAXPATH + 1;
    1709                 req.length = pRes->memlen - req.paramlen;
    1710                 pFEASrc = (FEALIST *)(pConn->mem + req.paramlen);
    1711                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    1712                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    1713                 {
    1714                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
     1253                        //rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    17151254                        switch (rc)
    17161255                        {
    … …  
    17331272                else
    17341273                {
    1735                         rc = buildFEALIST(pFEASrc, pGEAList, pFEAList);
     1274                        rc = buildFEALIST((FEALIST *)pFEASrc, pGEAList, pFEAList);
    17361275                }
    17371276        } while (0);
    1738         log("NdpEAQuery <%s> %d %d %d %d %d\n", pfi->pszName, rc, pFEASrc->cbList, pFEAList->cbList, pConn->rc, resp.rc);
     1277        log("NdpEAQuery <%s> %d %d %d\n", pfi->pszName, rc, pFEASrc->cbList, pFEAList->cbList);
     1278
    17391279        return rc;
    17401280}
    … …  
    17451285        Resource *pRes = pConn->pRes;
    17461286        int rc = 0;
    1747         smb_request req = {0};
    1748         smb_response resp = {0};
    17491287        char * path;
    17501288        unsigned long action;
    … …  
    17631301        }
    17641302
    1765         if (pFEAList->cbList > pRes->memlen)
    1766         {
    1767                 return ERROR_NOT_ENOUGH_MEMORY;
    1768         }
    1769 
    17701303        rc = ph->fsphGetFileInfoData(pfi, &fdata, 0);
    17711304        if (rc || !fdata.ulSize || !fdata.pData)
    … …  
    17781311
    17791312        do {
    1780                 rc = checkconnection(pConn);
    1781                 if (rc)
    1782                 {
    1783                         break;
    1784                 }
    1785 
    1786                 StrNCpy(pConn->mem, path, CCHMAXPATH);
    1787                 MemCpy(pConn->mem + CCHMAXPATH + 1, pFEAList, pFEAList->cbList);
    1788                 req.request = SMBREQ_SETEA;
    1789                 req.param = pConn->mem;
    1790                 req.paramlen = pFEAList->cbList + CCHMAXPATH + 1;
    1791                 req.length = req.paramlen;
    1792                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    1793                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    1794                 {
    1795                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
     1313                // got FEA there
     1314                FEA * pfea;
     1315                unsigned long done = sizeof(long);
     1316                pfea = pFEAList->list;
     1317                while (done < pFEAList->cbList)
     1318                {
     1319                        rc = smbwrp_setea(pConn->cli, path, (char*)(pfea + 1), pfea->cbValue ? (char *)(pfea + 1) + pfea->cbName + 1: NULL, pfea->cbValue);
     1320                        if (rc)
     1321                        {
     1322                                break;
     1323                        }
     1324                        pfea = (FEA *)((char *)(pfea + 1) + pfea->cbName + 1 + pfea->cbValue);
     1325                        done += sizeof(FEA) + pfea->cbName + 1 + pfea->cbValue;
    17961326                }
    17971327        } while (0);
    17981328        log("NdpEASet %d\n", rc);
     1329
    17991330        return rc;
    18001331}
    … …  
    18061337        int rc = 0;
    18071338        unsigned long action;
    1808         smb_request req = {0};
    1809         smb_response resp = {0};
    18101339        char * path = NULL;
    18111340        FEALIST * pfealist;
    18121341        NDDATABUF fdata = {0};
    18131342        smbwrp_fileinfo *finfo;
     1343        char    pBuffer[64*1024];
    18141344        int easize;
    18151345
    … …  
    18411371
    18421372        log("NdpEASize in <%s> \n", path);
     1373
    18431374        do {
    1844                 rc = checkconnection(pConn);
     1375                rc = smbwrp_listea(pConn->cli, path, pBuffer, sizeof( pBuffer));
     1376                pfealist = (FEALIST*)pBuffer;
    18451377                if (rc)
    18461378                {
    1847                         break;
    1848                 }
    1849 
    1850                 StrNCpy(pConn->mem, path, CCHMAXPATH);
    1851                 req.request = SMBREQ_LISTEA;
    1852                 req.param = pConn->mem;
    1853                 req.paramlen = CCHMAXPATH + 1;
    1854                 req.length = pRes->memlen - req.paramlen;
    1855                 pfealist = (FEALIST *)(pConn->mem + req.paramlen);
    1856                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    1857                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    1858                 {
    1859                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
     1379                        //rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    18601380                        switch (rc)
    18611381                        {
    … …  
    18771397                *pulEASize = pfealist->cbList;
    18781398        } while (0);
    1879         log("NdpEASize <%s> %d %d %d %d\n", pfi->pszName, *pulEASize, rc, pConn->rc, resp.rc);
     1399        log("NdpEASize <%s> %d %d\n", pfi->pszName, *pulEASize, rc);
     1400
    18801401        return rc;
    18811402}
    … …  
    18851406        Connection *pConn = (Connection *)conn;
    18861407        Resource *pRes = pConn->pRes;
    1887         smb_request req = {0};
    1888         smb_response resp = {0};
    18891408        int rc = 0;
    18901409        unsigned long action;
    … …  
    18921411       
    18931412        log("NdpSetCurrentDir in\n");
     1413
    18941414        do {
    1895                 rc = checkconnection(pConn);
    1896                 if (rc)
    1897                 {
    1898                         break;
    1899                 }
    1900 
    19011415                rc = pathparser(pRes, pConn, szPath, path);
    19021416                if (rc)
    … …  
    19051419                }
    19061420
    1907                 StrNCpy(pConn->mem, path, CCHMAXPATH);
    1908                 req.request = SMBREQ_CHDIR;
    1909                 req.param = pConn->mem;
    1910                 req.paramlen = CCHMAXPATH + 1;
    1911                 req.length = req.paramlen;
    1912                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    1913                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    1914                 {
    1915                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    1916                 }
     1421                rc = smbwrp_chdir(&pRes->srv, pConn->cli, path);
    19171422        } while (0);
    1918         log("NdpSetCurrentDir <%s> (%s) %d %d\n", szPath, path, rc, pConn->rc);
     1423        log("NdpSetCurrentDir <%s> (%s) %d\n", szPath, path, rc);
     1424
    19191425        return rc;
    19201426}
    … …  
    19361442        Connection *pConn = (Connection *)conn;
    19371443        Resource *pRes = pConn->pRes;
    1938         smb_request req = {0};
    1939         smb_response resp = {0};
    19401444        int rc = 0;
    19411445        unsigned long action;
    … …  
    19431447
    19441448        log("NdpForceDelete in\n");
     1449
    19451450        do {
    1946                 rc = checkconnection(pConn);
    1947                 if (rc)
    1948                 {
    1949                         break;
    1950                 }
    1951 
    19521451                rc = pathparser(pRes, pConn, szFile, path);
    19531452                if (rc)
    … …  
    19561455                }
    19571456
    1958                 StrNCpy(pConn->mem, path, CCHMAXPATH);
    1959                 req.request = SMBREQ_UNLINK;
    1960                 req.param = pConn->mem;
    1961                 req.paramlen = CCHMAXPATH + 1;
    1962                 req.length = req.paramlen;
    1963                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    1964                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    1965                 {
    1966                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    1967                 }
     1457                rc = smbwrp_unlink(pConn->cli, path);
    19681458        } while (0);
    1969         log("NdpForceDelete <%s> (%s) %d %d\n", szFile, path, rc, pConn->rc);
     1459        log("NdpForceDelete <%s> (%s) %d\n", szFile, path, rc);
     1460
    19701461        return rc;
    19711462}
    … …  
    19751466        Connection *pConn = (Connection *)conn;
    19761467        Resource *pRes = pConn->pRes;
    1977         smb_request req = {0};
    1978         smb_response resp = {0};
    19791468        int rc = 0;
    19801469        unsigned long action;
    … …  
    19821471
    19831472        log("NdpCreateDir in\n");
     1473
    19841474        do {
    1985                 rc = checkconnection(pConn);
    1986                 if (rc)
    1987                 {
    1988                         break;
    1989                 }
    1990 
    19911475                rc = pathparser(pRes, pConn, szDirName, path);
    19921476                if (rc)
    … …  
    19951479                }
    19961480
    1997                 StrNCpy(pConn->mem, path, CCHMAXPATH);
    1998                 req.request = SMBREQ_MKDIR;
    1999                 req.param = pConn->mem;
    2000                 req.paramlen = CCHMAXPATH + 1;
    2001                 req.length = req.paramlen;
    2002                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    2003                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    2004                 {
    2005                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    2006                 }
     1481                rc = smbwrp_mkdir(pConn->cli, path);
    20071482        } while (0);
    2008         log("NdpCreateDir <%s> (%s) %d %d\n", szDirName, path, rc, pConn->rc);
     1483        log("NdpCreateDir <%s> (%s) %d\n", szDirName, path, rc);
     1484
    20091485        return rc;
    20101486}
    … …  
    20141490        Connection *pConn = (Connection *)conn;
    20151491        Resource *pRes = pConn->pRes;
    2016         smb_request req = {0};
    2017         smb_response resp = {0};
    20181492        int rc = 0;
    20191493        unsigned long action;
    … …  
    20211495
    20221496        log("NdpDeleteDir in\n");
     1497
    20231498        do {
    2024                 rc = checkconnection(pConn);
    2025                 if (rc)
    2026                 {
    2027                         break;
    2028                 }
    2029 
    20301499                rc = pathparser(pRes, pConn, szDir, path);
    20311500                if (rc)
    … …  
    20341503                }
    20351504
    2036                 StrNCpy(pConn->mem, path, CCHMAXPATH);
    2037                 req.request = SMBREQ_RMDIR;
    2038                 req.param = pConn->mem;
    2039                 req.paramlen = CCHMAXPATH + 1;
    2040                 req.length = req.paramlen;
    2041                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    2042                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    2043                 {
    2044                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    2045                 }
     1505                rc = smbwrp_rmdir(pConn->cli, path);
    20461506        } while (0);
    2047         log("NdpDeleteDir <%s> (%s) %d %d\n", szDir, path, rc, pConn->rc);
     1507        log("NdpDeleteDir <%s> (%s) %d\n", szDir, path, rc);
     1508
    20481509        return rc;
    20491510}
    … …  
    20531514        Connection *pConn = (Connection *)conn;
    20541515        Resource *pRes = pConn->pRes;
    2055         smb_request req = {0};
    2056         smb_response resp = {0};
    20571516        int rc = 0;
    20581517        unsigned long action;
    … …  
    20611520        char * p = szDst;
    20621521
    2063         log("NdpMove in\n");
     1522        log("NdpMove in from <%s> to <%s>\n", szSrc, szDst);
     1523
    20641524        do
    20651525        {
    2066                 rc = checkconnection(pConn);
    2067                 if (rc)
    2068                 {
    2069                         break;
    2070                 }
    2071 
    20721526                rc = pathparser(pRes, pConn, szSrc, src);
    20731527                if (rc)
    … …  
    20871541                        p = szDst + l1 - l2 + 1;
    20881542                }
    2089                 StrNCpy(pConn->mem, src, CCHMAXPATH);
    2090                 pConn->mem[CCHMAXPATH + 1] = '\\';
    2091                 StrNCpy(pConn->mem + CCHMAXPATH + 2, p, CCHMAXPATH - 1);
    2092                 req.request = SMBREQ_RENAME;
    2093                 req.param = pConn->mem;
    2094                 req.paramlen = 2 * (CCHMAXPATH + 1);
    2095                 req.length = req.paramlen;
    2096                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    2097                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    2098                 {
    2099                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    2100                 }
     1543                //pConn->mem[CCHMAXPATH + 1] = '\\';
     1544                rc = smbwrp_rename(pConn->cli, src, p);
    21011545        } while (0);
    2102         log("NdpMove <%s> -> <%s> (%s) %d %d\n", szSrc, szDst, src, rc, pConn->rc);
     1546        log("NdpMove <%s> -> <%s> (%s) %d\n", szSrc, szDst, src, rc);
    21031547
    21041548        return rc;
    … …  
    21251569{
    21261570        Resource *pRes = pConn->pRes;
    2127         smb_request req = {0};
    2128         smb_response resp = {0};
    21291571        unsigned long action;
    21301572        int rc = 0;
    … …  
    21321574
    21331575        log("smbopen in %d\n", pConn->file.fd);
     1576
    21341577        do {
    21351578                if (pConn->file.fd > 0)
    21361579                {
    21371580                        rc = ERROR_TOO_MANY_OPEN_FILES;
    2138                         break;
    2139                 }
    2140 
    2141                 rc = checkconnection(pConn);
    2142                 if (rc)
    2143                 {
    21441581                        break;
    21451582                }
    … …  
    21641601                pConn->file.openattr = ulAttribute & 0x37;
    21651602                pConn->file.denymode = (ulOpenMode & 0x70) >> 4;
    2166                 MemCpy(pConn->mem, &pConn->file, sizeof(pConn->file));
    2167                 req.request = SMBREQ_OPEN;
    2168                 req.param = pConn->mem;
    2169                 req.paramlen = sizeof(pConn->file);
    2170                 req.length = req.paramlen;
    2171                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    2172                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    2173                 {
    2174                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    2175                 }
    2176                 else
    2177                 {
    2178                         MemCpy(&pConn->file, pConn->mem, sizeof(pConn->file));
    2179                 }
     1603                rc = smbwrp_open(pConn->cli, &pConn->file);
    21801604        } while (0);
    2181         log("smbopen <%s> (%s) %08x %08x %08x %d %d. file = %d\n", szFileName, path, flags, ulOpenMode, ulAttribute, rc, pConn->rc, pConn->file.fd);
     1605        log("smbopen <%s> (%s) %08x %08x %08x %d. file = %d\n", szFileName, path, flags, ulOpenMode, ulAttribute, rc, pConn->file.fd);
    21821606        if (!rc && pFEAList)
    21831607        {
    … …  
    22221646        int rc = 0;
    22231647        unsigned long action;
    2224         smb_request req = {0};
    2225         smb_response resp = {0};
    2226         smbwrp_fileinfo * finfo = (smbwrp_fileinfo *)pConn->mem;
     1648
     1649        smbwrp_fileinfo finfo;
    22271650        char path[CCHMAXPATH+1] = {0};
    22281651
    22291652        log("NdpSetFileAttribute in\n");
    22301653        do {
    2231                 rc = checkconnection(pConn);
    2232                 if (rc)
    2233                 {
    2234                         break;
    2235                 }
    2236 
    22371654                rc = pathparser(pRes, pConn, szFileName, path);
    22381655                if (rc)
    … …  
    22411658                }
    22421659
    2243                 MemSet(finfo, 0, sizeof(*finfo));
    2244 
    2245                 StrNCpy(finfo->fname, path, sizeof(finfo->fname) - 1);
    2246                 finfo->attr = usAttr & 0x37;
    2247                 req.request = SMBREQ_SETINFO;
    2248                 req.param = pConn->mem;
    2249                 req.paramlen = sizeof(*finfo);
    2250                 req.length = req.paramlen;
    2251                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    2252                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    2253                 {
    2254                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    2255                 }
     1660                MemSet(&finfo, 0, sizeof(finfo));
     1661                StrNCpy(finfo.fname, path, sizeof(finfo.fname) - 1);
     1662                finfo.attr = usAttr & 0x37;
     1663                rc = smbwrp_setattr(pConn->cli, &finfo);
    22561664        } while (0);
    2257         log("NdpSetFileAttribute <%s> (%s) %04x %d %d\n", szFileName, path, usAttr, rc, pConn->rc);
     1665        log("NdpSetFileAttribute <%s> (%s) %04x %d\n", szFileName, path, usAttr, rc);
     1666
    22581667        return rc;
    22591668}
    … …  
    22871696        int rc = 0;
    22881697        unsigned long action;
    2289         smb_request req = {0};
    2290         smb_response resp = {0};
    2291         FILEFINDBUF3 buf;
    2292         smbwrp_fileinfo * finfo = (smbwrp_fileinfo *)(pConn->mem + sizeof(pConn->file));
     1698        smbwrp_fileinfo finfo;
    22931699
    22941700        debug_printf("NdpFileQueryInfo in\n");
    … …  
    22991705                        break;
    23001706                }
    2301                 if (pConn->rc)
    2302                 {
    2303                         rc = ERROR_PIPE_NOT_CONNECTED;
    2304                         break;
    2305                 }
    2306 
    2307                 MemCpy(pConn->mem, &pConn->file, sizeof(pConn->file));
    2308                 StrNCpy(finfo->fname, pConn->file.fname, sizeof(finfo->fname) - 1);
    2309                 req.request = SMBREQ_FGETINFO;
    2310                 req.param = pConn->mem;
    2311                 req.paramlen = sizeof(pConn->file);
    2312                 req.length = req.paramlen + sizeof(*finfo);
    2313                 rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    2314                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    2315                 {
    2316                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    2317                 }
    2318                 else
    2319                 {
    2320                         finfo->easize = -1;
    2321                         if (ifL)
    2322                         {
    2323                                 getfindinfoL(pConn, plist, finfo, 0, NULL);
    2324                         }
    2325                         else
    2326                         {
    2327                                 getfindinfo(pConn, &buf, finfo);
    2328                                 ph->fsphAddFileFind32(plist, &buf, finfo, sizeof(*finfo), 0);
    2329                         }
     1707                StrNCpy(finfo.fname, pConn->file.fname, sizeof(finfo.fname) - 1);
     1708                rc = smbwrp_fgetattr(pConn->cli, &pConn->file, &finfo);
     1709                if (!rc)
     1710                {
     1711                        finfo.easize = -1;
     1712                        getfindinfoL(pConn, plist, &finfo, 0, NULL);
    23301713                }
    23311714        } while (0);
    2332         log("NdpFileQueryInfo <%s> %d %d\n", pConn->file.fd < 0 ? "!null!" : pConn->file.fname, rc, pConn->rc);
     1715        log("NdpFileQueryInfo <%s> %d\n", pConn->file.fd < 0 ? "!null!" : pConn->file.fname, rc);
    23331716
    23341717        return rc;
    … …  
    23411724        int rc = 0;
    23421725        unsigned long action;
    2343         smb_request req = {0};
    2344         smb_response resp = {0};
     1726        char pBuffer[64*1024];
    23451727        FEALIST * pFEASrc;
    23461728
    … …  
    23611743                        break;
    23621744                }
    2363                 if (pConn->rc)
    2364                 {
    2365                         rc = ERROR_PIPE_NOT_CONNECTED;
    2366                         break;
    2367                 }
    2368 
    2369                 MemCpy(pConn->mem, &pConn->file, sizeof(pConn->file));
    2370                 req.request = SMBREQ_FLISTEA;
    2371                 req.param = pConn->mem;
    2372                 req.paramlen = sizeof(pConn->file);
    2373                 req.length = pRes->memlen - req.paramlen;
    2374                 pFEASrc = (FEALIST *)(pConn->mem + req.paramlen);
    2375                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    2376                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    2377                 {
    2378                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
     1745                rc = smbwrp_flistea(pConn->cli, &pConn->file, pBuffer, sizeof( pBuffer));
     1746                pFEASrc = (FEALIST *) pBuffer;
     1747                if (rc)
     1748                {
     1749                        //rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    23791750                        switch (rc)
    23801751                        {
    … …  
    24001771                }
    24011772        } while (0);
    2402         log("NdpFileEAQuery out <%s>/%d pFEASrc->cbList=%d pFEAList->cbList=%d rc=%d %d %d\n", pConn->file.fname, pConn->file.fd, pFEASrc->cbList, pFEAList->cbList, rc, pConn->rc, resp.rc);
     1773        log("NdpFileEAQuery out <%s>/%d pFEASrc->cbList=%d pFEAList->cbList=%d rc=%d\n", pConn->file.fname, pConn->file.fd, pFEASrc->cbList, pFEAList->cbList, rc);
     1774
    24031775        return rc;
    24041776}
    … …  
    24091781        Resource *pRes = pConn->pRes;
    24101782        int rc = 0;
    2411         smb_request req = {0};
    2412         smb_response resp = {0};
    24131783        unsigned long action;
    24141784
    … …  
    24231793                return ERROR_EAS_NOT_SUPPORTED;
    24241794        }
    2425         if (pFEAList->cbList > pRes->memlen)
    2426         {
    2427                 return ERROR_NOT_ENOUGH_MEMORY;
    2428         }
    24291795
    24301796        do {
     1797                // got FEA there
     1798                FEA * pfea;
     1799                unsigned long done = sizeof(long);
    24311800                if (pConn->file.fd < 0)
    24321801                {
    … …  
    24341803                        break;
    24351804                }
    2436                 if (pConn->rc)
    2437                 {
    2438                         rc = ERROR_PIPE_NOT_CONNECTED;
    2439                         break;
    2440                 }
    2441 
    2442                 MemCpy(pConn->mem, &pConn->file, sizeof(pConn->file));
    2443                 MemCpy(pConn->mem + sizeof(pConn->file), pFEAList, pFEAList->cbList);
    2444                 req.request = SMBREQ_FSETEA;
    2445                 req.param = pConn->mem;
    2446                 req.paramlen = pFEAList->cbList + sizeof(pConn->file);
    2447                 req.length = req.paramlen;
    2448 
    2449                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    2450                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    2451                 {
    2452                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    2453                 }
     1805
     1806                pfea = pFEAList->list;
     1807                while (done < pFEAList->cbList)
     1808                {
     1809                        rc = smbwrp_fsetea(pConn->cli, &pConn->file, (char *)(pfea + 1), pfea->cbValue ? (char *)(pfea + 1) + pfea->cbName + 1: NULL, pfea->cbValue);
     1810                        if (rc)
     1811                        {
     1812                                break;
     1813                        }
     1814                        pfea = (FEA *)((char *)(pfea + 1) + pfea->cbName + 1 + pfea->cbValue);
     1815                        done += sizeof(FEA) + pfea->cbName + 1 + pfea->cbValue;
     1816                }
     1817
    24541818        } while (0);
    24551819        log("NdpFileEASet %d\n", rc);
     1820
    24561821        return rc;
    24571822}
    … …  
    24631828        int rc = 0;
    24641829        unsigned long action;
    2465         smb_request req = {0};
    2466         smb_response resp = {0};
    24671830        char path[CCHMAXPATH+1] = {0};
    2468         FEALIST * pfealist;
     1831        FEALIST * pFEAList;
     1832        char pBuffer[64*1024];
    24691833
    24701834        if (!pulEASize)
    … …  
    24841848                        break;
    24851849                }
    2486                 if (pConn->rc)
    2487                 {
    2488                         rc = ERROR_PIPE_NOT_CONNECTED;
    2489                         break;
    2490                 }
    2491 
    2492                 MemCpy(pConn->mem, &pConn->file, sizeof(pConn->file));
    2493                 req.request = SMBREQ_FLISTEA;
    2494                 req.param = pConn->mem;
    2495                 req.paramlen = sizeof(pConn->file);
    2496                 req.length = pRes->memlen - req.paramlen;
    2497                 pfealist = (FEALIST *)(pConn->mem + req.paramlen);
    2498                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    2499                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    2500                 {
    2501                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
     1850                rc = smbwrp_flistea(pConn->cli, &pConn->file, pBuffer, sizeof(pBuffer));
     1851                pFEAList = (FEALIST*) pBuffer;
     1852                if (rc)
     1853                {
     1854                        //rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    25021855                        switch (rc)
    25031856                        {
    … …  
    25051858                                case ERROR_PATH_NOT_FOUND :
    25061859                                {
    2507                                         pfealist->cbList = sizeof(pfealist->cbList);
     1860                                        pFEAList->cbList = sizeof(pFEAList->cbList);
    25081861                                } /* Fall through */
    25091862                                case ERROR_BUFFER_OVERFLOW :
    … …  
    25171870                        }
    25181871                }
    2519                 *pulEASize = pfealist->cbList;
     1872                *pulEASize = pFEAList->cbList;
    25201873        } while (0);
    2521         log("NdpFileEASize %d %d %d %d\n", *pulEASize, rc, pConn->rc, resp.rc);
     1874        log("NdpFileEASize %d %d\n", *pulEASize, rc);
     1875
    25221876        return rc;
    25231877}
    … …  
    25291883        int rc = 0;
    25301884        unsigned long action, attrFile;
    2531         smb_request req = {0};
    2532         smb_response resp = {0};
    2533         smbwrp_fileinfo * finfo = (smbwrp_fileinfo *)pConn->mem;
    25341885
    25351886        debug_printf("NdpFileSetInfo in\n");
    … …  
    25401891                        break;
    25411892                }
    2542                 if (pConn->rc)
    2543                 {
    2544                         rc = ERROR_PIPE_NOT_CONNECTED;
    2545                         break;
    2546                 }
    2547                 if (ifL)
    2548                 {
    2549                         attrFile = pfi->stat.attrFile;
    2550                 }
    2551                 else
    2552                 {
    2553                         FILESTATUS3 * stat = (FILESTATUS3 *)&(pfi->stat);
    2554                         attrFile = stat->attrFile;
    2555                 }
     1893                attrFile = pfi->stat.attrFile;
    25561894                // deferred setinfo - on closing the file
    25571895                pConn->file.openattr = attrFile;
    … …  
    25591897                debug_printf("NdpFileSetInfo mtime %d\n", pConn->file.mtime);
    25601898        } while (0);
    2561         log("NdpFileSetInfo <%s> %08x %d %d\n", pConn->file.fd < 0 ? "!null!" : pConn->file.fname, attrFile, rc, pConn->rc);
     1899        log("NdpFileSetInfo <%s> %08x %d\n", pConn->file.fd < 0 ? "!null!" : pConn->file.fname, attrFile, rc);
     1900
    25621901        return NO_ERROR;
    25631902}
    … …  
    25691908        int rc = 0;
    25701909        unsigned long action;
    2571         smb_request req = {0};
    2572         smb_response resp = {0};
    25731910
    25741911        log("NdpFileSetFilePtrl in\n");
     1912
    25751913        do {
    25761914                if (pConn->file.fd < 0)
    … …  
    25791917                        break;
    25801918                }
    2581                 if (pConn->rc)
    2582                 {
    2583                         rc = ERROR_PIPE_NOT_CONNECTED;
    2584                         break;
    2585                 }
    2586 
    2587                 MemCpy(pConn->mem, &pConn->file, sizeof(pConn->file));
    2588                 *(unsigned long *)(pConn->mem + sizeof(pConn->file)) = ulMethod;
    2589                 *(long long *)(pConn->mem + sizeof(pConn->file) + sizeof(long)) = llOffset;
    2590                 req.request = SMBREQ_LSEEK;
    2591                 req.param = pConn->mem;
    2592                 req.paramlen = sizeof(pConn->file) + sizeof(long) + sizeof(long long);
    2593                 req.length = req.paramlen;
    2594                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    2595                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    2596                 {
    2597                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    2598                 }
    2599                 else
    2600                 {
    2601                         MemCpy(&pConn->file, pConn->mem, sizeof(pConn->file));
     1919
     1920                rc = smbwrp_lseek(pConn->cli, &pConn->file, ulMethod, llOffset);
     1921                if (!rc)
    26021922                        *pllActual = pConn->file.offset;
    2603                 }
     1923
    26041924        } while (0);
    2605         log("NdpFileSetFilePtrL <%s> %lld %lu %lld %d %d\n", pConn->file.fd < 0 ? "!null!" : pConn->file.fname, llOffset, ulMethod, *pllActual, rc, pConn->rc);
     1925        log("NdpFileSetFilePtrL <%s> %lld %lu %lld %d\n", pConn->file.fd < 0 ? "!null!" : pConn->file.fname, llOffset, ulMethod, *pllActual, rc);
    26061926
    26071927        return rc;
    … …  
    26231943        int rc = 0;
    26241944        unsigned long action;
    2625         smb_request req = {0};
    2626         smb_response resp = {0};
    26271945
    26281946        log("NdpFileClose in %d <%s>\n", pConn->file.fd, pConn->file.fd < 0 ? "!null!" : pConn->file.fname);
    … …  
    26341952                        break;
    26351953                }
    2636                 if (pConn->rc)
    2637                 {
    2638                         rc = ERROR_PIPE_NOT_CONNECTED;
    2639                         break;
    2640                 }
    2641 
    2642                 MemCpy(pConn->mem, &pConn->file, sizeof(pConn->file));
    2643                 req.request = SMBREQ_CLOSE;
    2644                 req.param = pConn->mem;
    2645                 req.length = pRes->memlen;
    2646                 req.paramlen = sizeof(pConn->file);
    2647                 req.length = req.paramlen;
    2648                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    2649                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    2650                 {
    2651                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    2652                 }
    2653                 else
    2654                 {
    2655                         MemCpy(&pConn->file, pConn->mem, sizeof(pConn->file));
    2656                 }
     1954
     1955                rc = smbwrp_close(pConn->cli, &pConn->file);
     1956
    26571957        } while (0);
    2658         log("NdpFileClose %d %d %d\n", pConn->file.fd, rc, pConn->rc);
     1958        log("NdpFileClose %d %d\n", pConn->file.fd, rc);
     1959
    26591960        pConn->file.fd = -1;
    26601961        return rc;
    … …  
    26811982        int rc = 0;
    26821983        unsigned long action;
    2683         smb_request req = {0};
    2684         smb_response resp = {0};
    26851984
    26861985        log("NdpFileNewSizeL in\n");
     1986
    26871987        do {
    26881988                if (pConn->file.fd < 0)
    … …  
    26911991                        break;
    26921992                }
    2693                 if (pConn->rc)
    2694                 {
    2695                         rc = ERROR_PIPE_NOT_CONNECTED;
    2696                         break;
    2697                 }
    2698 
    2699                 MemCpy(pConn->mem, &pConn->file, sizeof(pConn->file));
    2700                 *(long long *)(pConn->mem + sizeof(pConn->file)) = llLen;
    2701 
    2702                 req.request = SMBREQ_NEWSIZE;
    2703                 req.param = pConn->mem;
    2704                 req.paramlen = sizeof(pConn->file) + sizeof(long long);
    2705                 req.length = req.paramlen;
    2706 
    2707                 pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    2708                 if (pConn->rc || action < sizeof(resp) || resp.rc)
    2709                 {
    2710                         rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    2711                 }
    2712                 else
    2713                 {
    2714                         MemCpy(&pConn->file, pConn->mem, sizeof(pConn->file));
    2715                 }
     1993
     1994                rc = smbwrp_setfilesize(pConn->cli, &pConn->file, llLen);
     1995
    27161996        } while (0);
    2717         log("NdpFileNewSizeL <%s> %lld %d %d\n", pConn->file.fd < 0 ? "!null!" : pConn->file.fname, llLen, rc, pConn->rc);
     1997        log("NdpFileNewSizeL <%s> %lld %d\n", pConn->file.fd < 0 ? "!null!" : pConn->file.fname, llLen, rc);
     1998
    27181999        return rc;
    27192000}
    … …  
    27272008        unsigned long onedone;
    27282009        unsigned long action;
    2729         smb_request req = {0};
    2730         smb_response resp = {0};
    27312010
    27322011        log("NdpFileRead in\n");
    2733 //      log("NdpFileRead <%s> %lu\n", pConn->file.fd < 0 ? "!null!" : pConn->file.fname, ulRead);
    27342012
    27352013        do {
    … …  
    27392017                        break;
    27402018                }
    2741                 if (pConn->rc)
    2742                 {
    2743                         rc = ERROR_PIPE_NOT_CONNECTED;
    2744                         break;
    2745                 }
    2746        
    2747                 MemCpy(pConn->mem, &pConn->file, sizeof(pConn->file));
    2748                 req.request = SMBREQ_READ;
    2749                 req.param = pConn->mem;
    2750                 req.paramlen = sizeof(pConn->file);
    2751 
    2752                 while (done < ulRead)
    2753                 {
    2754                         req.length = req.paramlen + (pRes->memlen - req.paramlen < (ulRead - done) ? pRes->memlen - req.paramlen : (ulRead - done));
    2755        
    2756                         pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    2757                         if (pConn->rc || action < sizeof(resp) || resp.rc)
    2758                         {
    2759                                 rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    2760                                 break;
    2761                         }
    2762                         if (resp.value == 0)
    2763                         {
    2764                                 break;
    2765                         }
    2766                         onedone = resp.value > req.length ? req.length : resp.value;
    2767                         MemCpy((char *)pBuffer + done, pConn->mem + sizeof(pConn->file), onedone);
    2768                         done += onedone;
    2769                 }
    2770                 MemCpy(&pConn->file, pConn->mem, sizeof(pConn->file));
    2771                 *pulActual = done;
     2019                rc = smbwrp_read(pConn->cli, &pConn->file, pBuffer, ulRead, pulActual);
     2020                //*pulActual = ulRead;
     2021                //DosSleep(0);
     2022
    27722023        } while (0);
    2773         log("NdpFileRead <%s> %lu %lu %d %d\n", pConn->file.fd < 0 ? "!null!" : pConn->file.fname, ulRead, *pulActual, rc, pConn->rc);
     2024        log("NdpFileRead <%s> %lu %lu %d\n", pConn->file.fd < 0 ? "!null!" : pConn->file.fname, ulRead, *pulActual, rc);
    27742025
    27752026        return rc;
    … …  
    27842035        unsigned long onedone;
    27852036        unsigned long action;
    2786         smb_request req = {0};
    2787         smb_response resp = {0};
    27882037
    27892038        log("NdpFileWrite in\n");
     2039
    27902040        do {
    27912041                if (pConn->file.fd < 0)
    … …  
    27942044                        break;
    27952045                }
    2796                 if (pConn->rc)
    2797                 {
    2798                         rc = ERROR_PIPE_NOT_CONNECTED;
    2799                         break;
    2800                 }
    2801        
    2802                 MemCpy(pConn->mem, &pConn->file, sizeof(pConn->file));
    2803                 req.request = SMBREQ_WRITE;
    2804                 req.param = pConn->mem;
    2805                 req.paramlen = sizeof(pConn->file);
    2806 
    2807                 while (done < ulWrite)
    2808                 {
    2809                         req.length = pRes->memlen - req.paramlen < (ulWrite - done) ? pRes->memlen - req.paramlen : (ulWrite - done);
    2810                         MemCpy(pConn->mem + sizeof(pConn->file), (char *)pBuffer + done, req.length);
    2811                         req.length += req.paramlen;
    2812 
    2813                         pConn->rc = _DosTransactNPipe(pConn, &req, sizeof(req), &resp, sizeof(resp), &action);
    2814                         if (pConn->rc || action < sizeof(resp) || resp.rc)
    2815                         {
    2816                                 rc = pConn->rc ? pConn->rc : (resp.rc ? resp.rc : ERROR_INVALID_PARAMETER);
    2817                                 break;
    2818                         }
    2819                         done += resp.value & 0xFFFFFFFF;
    2820                         if (resp.value < req.length)
    2821                         {
    2822                                 break;
    2823                         }
    2824                 }
    2825                 MemCpy(&pConn->file, pConn->mem, sizeof(pConn->file));
    2826                 *pulActual = done;
     2046                rc = smbwrp_write(pConn->cli, &pConn->file, pBuffer, ulWrite, pulActual);
     2047
    28272048        } while (0);
    2828         log("NdpFileWrite <%s> %lu %lu %d %d\n", pConn->file.fd < 0 ? "!null!" : pConn->file.fname, ulWrite, *pulActual, rc, pConn->rc);
    2829 
    2830         return rc;
    2831 }
     2049        log("NdpFileWrite <%s> %lu %lu %d\n", pConn->file.fd < 0 ? "!null!" : pConn->file.fname, ulWrite, *pulActual, rc);
     2050
     2051        return rc;
     2052}
     2053

  • branches/client-1.5/src/smbwrp.c

    r129 r145  
    377377return a connection to a server
    378378*******************************************************/
    379 int _System smbwrp_connect(smbwrp_server * srv, struct cli_state ** cli, int krb5support)
    380 {
     379int _System smbwrp_connect( Resource* pRes, cli_state ** cli)
     380{
     381        smbwrp_server * srv = &pRes->srv;
    381382        char * server = srv->server_name;
    382383        char * share = *(srv->share_name) ? srv->share_name : "IPC$";
    … …  
    440441        }
    441442
    442         if (krb5support == 1){
    443         debuglocal(1,"Kerberos support enabled\n");
    444                 c->use_kerberos = True;}
     443        if (pRes->krb5support == 1)
     444        {
     445            debuglocal(1,"Kerberos support enabled\n");
     446            c->use_kerberos = True;
     447        }
    445448
    446449        if (!cli_session_request(c, &calling, &called)) {
    … …  
    492495        debuglocal(4," tconx ok. cli caps %08x\n", c->capabilities);
    493496
    494         // copy back cli_state
     497        // save cli_state pointer
    495498        *cli = c;
    496499
    497 //      srv->dev = (dev_t)(str_checksum(server) ^ str_checksum(share));
    498 
    499500        return 0;
    500501}
    … …  
    503504close a connection to a server
    504505*******************************************************/
    505 void _System smbwrp_disconnect(struct cli_state ** cli)
    506 {
    507         if (cli)
     506void _System smbwrp_disconnect( Resource* pRes, cli_state * cli)
     507{
     508        if (pRes && cli)
    508509        {
    509510                // this call will free all buffers, close handles and free cli mem
    510                 cli_shutdown(*cli);
    511                 // set to zero because no longer valid
    512                 *cli = 0;
     511                cli_shutdown( cli);
    513512        }
    514513}
    … …  
    933932
    934933// =============================DIRECTORY ROUTINES============================
    935 
     934                                                                                                               
    936935/*****************************************************
    937936add a entry to a directory listing
    … …  
    942941        {
    943942                filelist_state * st  = (filelist_state *)state;
    944                 if (st->add_dir_entry)
    945                 {
    946 debuglocal(8,"adding <%s> %d %d\n", finfo->fname, sizeof(st->finfo), st->datalen);
    947                         memcpy(&st->finfo, finfo, sizeof(st->finfo));
    948                         st->add_dir_entry(state);
    949                 }
    950         }
    951 }
    952 
    953 #if 0
    954 static void smbwrp_dir_add_old(struct file_info *finfo, const char *mask, void *state)
    955 {
    956         if (state && finfo)
    957         {
    958                 filelist_state * st  = (filelist_state *)state;
    959                 if (st->add_dir_entry)
    960                 {
    961                         strncpy(st->finfo.fname, finfo->name, sizeof(st->finfo.fname) - 1);
    962                         st->finfo.size = finfo->size;
    963                         st->finfo.easize = -1;
    964                         st->finfo.attr = finfo->mode;
    965                         st->finfo.ctime = finfo->ctime_ts.tv_sec - get_time_zone(finfo->ctime_ts.tv_sec);
    966                         st->finfo.mtime = finfo->mtime_ts.tv_sec - get_time_zone(finfo->mtime_ts.tv_sec);
    967                         st->finfo.atime = finfo->atime_ts.tv_sec - get_time_zone(finfo->atime_ts.tv_sec);
    968                         st->add_dir_entry(state);
    969                 }
    970         }
    971 }
    972 #endif
     943                char fullname[ _MAX_PATH];
     944                debuglocal(8,"adding <%s> %d %d\n", finfo->fname, sizeof(st->finfo), st->datalen);
     945                memcpy(&st->finfo, finfo, sizeof(st->finfo));
     946                StrCpy(fullname, st->dir);
     947                StrCat(fullname, finfo->fname);
     948                StrCpy(st->finfo.fname, fullname);
     949                getfindinfoL( st->pConn, st->plist, &st->finfo, st->ulAttribute, st->dir_mask);
     950        }
     951}
    973952
    974953static void smbwrp_special_add(const char * name, void * state)
    … …  
    14701449                             smbwrp_dir_add, state) < 0)
    14711450#endif
    1472                 {
     1451                {                                                                             
    14731452                        return os2cli_errno(cli);
    14741453                }
    1475         }
     1454        }                                                                                                                                               
    14761455
    14771456        return 0;
    … …  
    17191698        return 0;
    17201699}
     1700
     1701
     1702char * getlastslash(char * path)
     1703{
     1704        char * p;
     1705        if (!path)
     1706        {
     1707                return NULL;
     1708        }
     1709        for (p = path + strlen(path) - 1; p >= path; p--)
     1710        {
     1711                if (*p == '\\' || *p == '/')
     1712                {
     1713                        return p;
     1714                }
     1715        }
     1716        return NULL;
     1717}
     1718

  • branches/client-1.5/src/smbwrp.h

    r107 r145  
    9494
    9595
    96 typedef struct filelist_state
    97 {
    98         unsigned long pipe;
    99         char * data;
    100         int datalen;
    101         int bufferlen;
    102         void ( * _System add_dir_entry)(void * st);
    103         char mask[261];
    104         smbwrp_fileinfo finfo;
    105 } filelist_state;
    106 
    10796#ifndef INCL_DOS
    10897typedef struct _FSALLOCATE      /* fsalloc */
    … …  
    116105#endif
    117106
     107typedef struct _Resource
     108{
     109        int rootlevel;
     110        smbwrp_server srv;
     111        char logfile[_MAX_PATH + 1];
     112        char loglevel;
     113        int easupport;
     114        int krb5support;
     115} Resource;
     116
     117typedef struct _Connection
     118{
     119        Resource *pRes;
     120        cli_state* cli;
     121        smbwrp_file file;
     122} Connection;
     123
     124
     125typedef struct filelist_state
     126{
     127        unsigned long pipe;
     128        char * data;
     129        int datalen;
     130        int bufferlen;
     131        void ( * _System add_dir_entry)(void * st);
     132        char mask[ _MAX_PATH];
     133        char dir[ _MAX_PATH];
     134        char dir_mask[ _MAX_PATH];
     135        smbwrp_fileinfo finfo;
     136        Connection* pConn;
     137        void *plist;
     138        unsigned long ulAttribute;
     139} filelist_state;
    118140
    119141#pragma pack()
    … …  
    121143int _System smbwrp_getclisize(void);
    122144int _System smbwrp_init(void);
    123 int _System smbwrp_connect(smbwrp_server * srv, cli_state ** c, int krb5support);
    124 void _System smbwrp_disconnect(cli_state ** cli);
     145int _System smbwrp_connect(Resource * pRes, cli_state **);
     146void _System smbwrp_disconnect(Resource * pRes, cli_state *);
    125147int _System smbwrp_open(cli_state * cli, smbwrp_file * file);
    126148int _System smbwrp_read(cli_state * cli, smbwrp_file * file, void *buf, unsigned long count, unsigned long * result);
Note: See TracChangeset for help on using the changeset viewer.