Changeset 145 for branches


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
     5
     6
     7
     8
     9
    410
    5 VERSION         = 1.0.15
    6 BUILD           = 15
     11VERSION         = 1.
     12BUILD           =
    713
    8 SAMBA           = ..
    9 TOOLKIT         = E:\dev\toolkit452
     14SAMBA           = ..
     15TOOLKIT         = :\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
     30
    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
     37
     38
     39
    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" -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
    5565        rm *.map
    5666        rm *.dll
    5767        rm *.hlp
     68

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

    r131 r145  
     1
     2
     3
     4
     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
     16
     17
    1818void log(const char *fmt, ...)
    1919{ 
    … …  
    4242        }
    4343}
     44
    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->srv.share_name;
    388271        }
    389272        StrNCpy(stat->achName, name, CCHMAXPATHCOMP - 1);
    … …  
    413296        if (!*name)
    414297        {
    415                 name = pConn->srv.share_name;
     298                name = pConn->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)
    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
     397
     398
     399
     400
    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
    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
    814580        if (rootlevel < 3)
    815581        {
    … …  
    902668                }
    903669        }
     670
    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        ;
     686        ;
     687        ;
    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
     707
     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       
    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);
    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                        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
    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
     838
     839
    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 = );
    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
     868
     869
     870
     871
     872
     873
     874
     875
     876
     877
     878
     879
     880
     881
     882
     883
     884
     885
     886
     887
     888
     889
     890
     891
     892
     893
     894
     895
     896
     897
     898
     899
     900
     901
    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                Info 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
    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 =;
    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(finfofname, '\\');
     1017                                if (p && p > finfofname)
    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 = );
     1021                                        if (rc)
    15181022                                        {       
    1519                                                 rc = pConn->rc ? pConn->rc : (resp.rc ? ERROR_PATH_NOT_FOUND : ERROR_INVALID_PARAMETER);
     1023                                                rc = ;
    15201024                                        }
    15211025                                }
    15221026                        }
    15231027                } while (0);
    1524                 log("NdpQueryInfo <%s> (%s) %d %d\n", szPath, path, rc, pConn->rc);
     1028                log("NdpQueryrc);
    15251029                retry = rc && !retry;
     1030
    15261031        } while (retry);
    15271032       
     1033
     1034
     1035
     1036
     1037
     1038
     1039
     1040
     1041
     1042
     1043
     1044
     1045
     1046
     1047
     1048
     1049
     1050
     1051
     1052
     1053
     1054
     1055
     1056
     1057
     1058
     1059
     1060
     1061
     1062
     1063
     1064
     1065
     1066
     1067
     1068
     1069
     1070
     1071
     1072
     1073
     1074
     1075
     1076
     1077
     1078
     1079
     1080
     1081
     1082
     1083
     1084
     1085
     1086
     1087
     1088
     1089
     1090
     1091
     1092
     1093
     1094
     1095
     1096
     1097
     1098
     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
    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(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
    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) %drc);
    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 %drc, 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> %drc);
    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
     1798
     1799
    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                                        pist->cbList);
    25081861                                } /* Fall through */
    25091862                                case ERROR_BUFFER_OVERFLOW :
    … …  
    25171870                        }
    25181871                }
    2519                 *pulEASize = pfealist->cbList;
     1872                *pulEASize = pist->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 %drc);
    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 %drc);
    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        //
    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(* cli)
     507{
     508        if (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
     1702
     1703
     1704
     1705
     1706
     1707
     1708
     1709
     1710
     1711
     1712
     1713
     1714
     1715
     1716
     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
     107
     108
     109
     110
     111
     112
     113
     114
     115
     116
     117
     118
     119
     120
     121
     122
     123
     124
     125
     126
     127
     128
     129
     130
     131
     132
     133
     134
     135
     136
     137
     138
     139
    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();
     146void _System smbwrp_disconnect();
    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.