← Back to branch summary

~ubuntu-branches/ubuntu/lucid/ncpfs/lucid

« back to all changes in this revision

Viewing changes to lib/nwclient.c

  • Committer: Bazaar Package Importer
  • Author(s): Anibal Monsalve Salazar
  • Date: 2005-02-09 21:58:40 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20050209215840-kxxhph7upknpbcdl
Tags: 2.2.6-1
http://bugs.debian.org/293446
http://bugs.debian.org/283617
http://bugs.debian.org/260024
http://bugs.debian.org/162267
http://bugs.debian.org/260021
http://bugs.debian.org/267315
http://bugs.debian.org/284169
http://bugs.debian.org/260020
* New upstream version.
  Fixed "CAN-2005-0013 and CAN-2005-0014" (Closes: #293446).
* Previous release ncpfs-2.2.5 fixed "ncpfs buffer overflow"
  and is also fixed in ncpfs-2.2.6 (Closes: #283617).
* Incorporate and acknowledge the changes from the non maintainer
  upload 2.2.4-1.1 (Closes: #260024).
* Fixed "Should suggest libpam-ncp?", it now depends on libpam-ncp
  (Closes: #162267).
* Fixed "upstream location in the copyright file is outdated"
  (Closes: #260021).
* Fixed "ncpfs override disparity" (Closes: #267315).
* Fixed "FTBFS (amd64/gcc-4.0)" (Closes: #284169).
* Fixed "Please remove an outdated part of the package description"
  (Closes: #260020).

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/nwclient.c
96
96
 
97
97
#if 1
98
98
/*read hard degugging*/
99
 
 void printConn (NWCONN_HANDLE conn, int stage) {
 
99
void printConn (NWCONN_HANDLE conn, int stage);
 
100
void printConn (NWCONN_HANDLE conn, int stage) {
100
101
        printf("%s\n",conn->mount_point);
101
102
        printf ("------ info from kernel--------------------------------\n");
102
103
        printf ("infoV2.version %d\n",conn->i.version);
135
136
        printf ("serverInfo.version.revision %x\n",conn->serverInfo.version.revision);
136
137
 
137
138
        printf ("NET_ADDRESS_TYPE nt %x\n",conn->nt);
138
 
 
139
 
 
140
 
 }
 
139
}
141
140
#endif
142
141
 
143
142
static int NWCIsPermanentConnection (NWCONN_HANDLE conn) {
144
 
  return (ncp_get_conn_type(conn) == NCP_CONN_PERMANENT);
 
143
        return (ncp_get_conn_type(conn) == NCP_CONN_PERMANENT);
145
144
}
146
145
 
147
146
NWCCODE NWCXGetPermConnInfo(NWCONN_HANDLE conn, nuint info, size_t len, void* buffer) {
354
353
}
355
354
 
356
355
#ifdef NDS_SUPPORT
357
 
/* copied from ndslib.c */
358
 
static void strcpy_cw(wchar_t *w, const char* s) {
359
 
        while ((*w++ = *(const nuint8*)s++) != 0);
360
 
}
361
 
 
362
 
NWDSCCODE NWDSCreateContextHandleMnt(NWDSContextHandle* ctx, const NWDSChar * treeName){
363
 
 
 
356
NWDSCCODE NWDSSetContextHandleTree(NWDSContextHandle ctx, const NWDSChar * treeName)
 
357
{
364
358
#define MAXCONNS 64
365
 
  NWDSCCODE err;
366
 
  NWCONN_HANDLE conns[MAXCONNS];
367
 
 
368
 
  int curEntries=0;
369
 
  NWDS_HANDLE dxh;
370
 
  int i;
371
 
  union __NWDSAuthInfo * ndai;
372
 
  size_t authinfo_len;
373
 
  wchar_t wc_treeName[MAX_DN_CHARS+1];
374
 
 
375
 
  if (!treeName)
376
 
      return ERR_NULL_POINTER;
377
 
 
378
 
  strcpy_cw (wc_treeName,treeName);
379
 
 
380
 
  err=NWDSCreateContextHandle (ctx);
381
 
  if (err)
382
 
       return err;
383
 
 
384
 
  err= NWCXGetPermConnListByTreeName (conns,MAXCONNS,&curEntries,getuid(),treeName);
385
 
  if (err) {
386
 
     NWDSFreeContext(*ctx);
387
 
     return (err);
388
 
  }
389
 
/*  printf ("got %d connexion(s) to %s \n",curEntries,treeName);*/
390
 
  dxh=(*ctx)->ds_connection;
391
 
  if (! dxh){  /* should not be ???*/
392
 
           NWDSFreeContext(*ctx);
393
 
           return EINVAL;
394
 
   }
395
 
  for (i=0; i <curEntries;i++) {
396
 
     NWCONN_HANDLE conn = conns[i];
397
 
     err=NWDSAddConnection (*ctx,conn);
398
 
 
399
 
     if (err) {
400
 
/*            printf ("error adding connection \n");*/
401
 
            NWCCCloseConn(conn);
402
 
            continue;
403
 
     }
404
 
     if (!dxh->authinfo) {
405
 
/*        printf ("trying to get authinfo \n");*/
406
 
        err = ncp_get_private_key(conn, NULL, &authinfo_len);
407
 
        if (err)
408
 
                  continue;       /* kernel without private key support */
409
 
        if (!authinfo_len)
410
 
                   continue;       /* no private key on this connection */
411
 
        ndai = (union __NWDSAuthInfo*)malloc(authinfo_len);
412
 
        if (!ndai)
413
 
                continue;       /* not enough memory */
414
 
        err = ncp_get_private_key(conn, ndai, &authinfo_len);
415
 
        if (err) {
416
 
                free(ndai);
417
 
                continue;
418
 
        }
419
 
/*        printf ("got authinfo \n");*/
420
 
        mlock(ndai, authinfo_len);
421
 
        dxh->authinfo = ndai;
422
 
        if (dxh->dck.tree_name)
423
 
            free(dxh->dck.tree_name);
424
 
        dxh->dck.tree_name=wcsdup(wc_treeName);
425
 
     }
426
 
 
427
 
  }
428
 
  return 0;
429
 
 
430
 
}
431
 
 
 
359
        NWDSCCODE err;
 
360
        NWCONN_HANDLE conns[MAXCONNS];
 
361
        int curEntries;
 
362
        int i;
 
363
        wchar_t treeNameW[MAX_DN_CHARS+1];
 
364
        char treeNameUTF[MAX_DN_CHARS*4 + 1];
 
365
 
 
366
        if (!treeName)
 
367
                return ERR_NULL_POINTER;
 
368
 
 
369
        err = NWDSXlateFromCtx(ctx, treeNameW, sizeof(treeNameW), treeName);
 
370
        if (err)
 
371
                return err;
 
372
        err = iconv_wchar_t_to_external(treeNameW, treeNameUTF, sizeof(treeNameUTF));
 
373
        if (err)
 
374
                return err;
 
375
        err = NWDSSetTreeNameW(ctx, treeNameW);
 
376
        if (err) {
 
377
                return err;
 
378
        }
 
379
        err = NWCXGetPermConnListByTreeName(conns, MAXCONNS, &curEntries, getuid(), treeNameUTF);
 
380
        if (err) {
 
381
                return err;
 
382
        }
 
383
        for (i = 0; i < curEntries; i++) {
 
384
                NWCONN_HANDLE conn = conns[i];
 
385
                err = NWDSAddConnection(ctx, conn);
 
386
                if (err) {
 
387
                        NWCCCloseConn(conn);
 
388
                        continue;
 
389
                }
 
390
        }
 
391
        return 0;
 
392
}
 
393
 
 
394
NWDSCCODE NWDSCreateContextHandleMnt(NWDSContextHandle* pctx, const NWDSChar * treeName)
 
395
{
 
396
        NWDSCCODE err;
 
397
        NWDSContextHandle ctx;
 
398
 
 
399
        if (!pctx) {
 
400
                return ERR_NULL_POINTER;
 
401
        }
 
402
        err = NWDSCreateContextHandle(&ctx);
 
403
        if (err)
 
404
                return err;
 
405
        err = NWDSSetContextHandleTree(ctx, treeName);
 
406
        if (err)
 
407
                NWDSFreeContext(ctx);
 
408
        else
 
409
                *pctx = ctx;
 
410
        return err;
 
411
}
432
412
 
433
413
//#define NOENV 1  <-- testing reading of .nwinfos file
434
414
#undef NOENV
497
477
                *err = errno;
498
478
                return NULL;
499
479
        }
 
480
        if (st.st_uid != getuid()) {
 
481
                *err = EACCES;
 
482
                return NULL;
 
483
        }
500
484
        if ((st.st_mode & (S_IRWXO | S_IRWXG)) != 0) {
501
485
                *err = NCPLIB_INVALID_MODE;
502
486
                return NULL;
833
817
         and return them as strings with comma separators
834
818
attributes with fields are emitted on a single line with "," as separator*/
835
819
 
836
 
static NWDSCCODE __docopy_string (NWDSContextHandle ctx, const void* val,
 
820
static NWDSCCODE __docopy_string (UNUSED(NWDSContextHandle ctx), const void* val,
837
821
                                   const enum SYNTAX synt, size_t currentSize,
838
822
                                   char* result, size_t maxSize){
839
 
  NWDSCCODE err;
840
 
  char tmpBuf [MAX_DN_BYTES+1];
841
 
 
 
823
  int l;
842
824
#ifdef DEBUG_PRINT
843
825
  printf ("__docopy_string got :%s synt = %d cursize=%d maxsize= %d\n",(char *)val,synt,currentSize,maxSize );
844
826
#endif
845
827
 
846
 
  if (currentSize >maxSize) return NWE_BUFFER_OVERFLOW;
 
828
  if (currentSize > maxSize) return NWE_BUFFER_OVERFLOW;
847
829
  if (!result) return ERR_NULL_POINTER;
848
830
  switch (synt) {
849
831
        case SYN_DIST_NAME:
850
 
              /*
851
 
              err = NWDSAbbreviateName(ctx, val, tmpBuf);
852
 
              if (err)
853
 
                  return err;
854
 
              //strcpy (result,tmpBuf);
855
 
              *************************/
856
 
             strcpy(result,val);
857
 
              break;
858
832
        case SYN_CI_STRING:
859
833
        case SYN_CE_STRING:
860
834
        case SYN_PR_STRING:
861
835
        case SYN_NU_STRING:
862
836
        case SYN_TEL_NUMBER:
863
837
        case SYN_CLASS_NAME:
864
 
                strcpy(result,val);
865
 
                break;
 
838
                l = snprintf(result, maxSize, "%s", (const char *)val);
 
839
                break;
866
840
        case SYN_PATH:{
867
841
                const Path_T* p = (const Path_T*)val;
868
 
                if (strlen(p->volumeName)+strlen(p->path)+2+2+1>=maxSize)
869
 
                        return NWE_BUFFER_OVERFLOW;
870
 
                sprintf(result,"%u,%s,%s", p->nameSpaceType,p->volumeName, p->path);
 
842
 
 
843
                l = snprintf(result, maxSize, "%u,%s,%s", p->nameSpaceType, p->volumeName, p->path);
871
844
                }
872
845
                break;
873
846
        case SYN_TYPED_NAME:{
874
847
                const Typed_Name_T* tn = (const Typed_Name_T*)val;
875
 
                if (strlen(tn->objectName)+8+8+2+1>=maxSize)
876
 
                        return NWE_BUFFER_OVERFLOW;
877
 
                sprintf(result,"%u,%u,%s", tn->interval,tn->level,tn->objectName);
 
848
 
 
849
                l = snprintf(result, maxSize, "%u,%u,%s", tn->interval, tn->level, tn->objectName);
878
850
                }
879
851
                break;
880
852
        case SYN_FAX_NUMBER:{
881
853
                const Fax_Number_T* fn = (const Fax_Number_T*)val;
882
 
                if (strlen(fn->telephoneNumber)+2+1+1>=maxSize)
883
 
                        return NWE_BUFFER_OVERFLOW;
884
 
                sprintf(result,"%s,%u", fn->telephoneNumber,fn->parameters.numOfBits);
 
854
                
 
855
                l = snprintf(result, maxSize, "%s,%u", fn->telephoneNumber, fn->parameters.numOfBits);
885
856
                }
886
857
                break;
887
858
        case SYN_EMAIL_ADDRESS:{
888
859
                const EMail_Address_T* ea = (const EMail_Address_T*)val;
889
860
                /*change the SMTP:aaa@bbbb to SMTP,aaa@bbbb */
890
861
                char* p=strchr(ea->address,':');
891
 
                if (strlen(ea->address)+2+1+1>=maxSize)
892
 
                        return NWE_BUFFER_OVERFLOW;
893
862
 
894
863
                if (p) *p=',';
895
 
                sprintf(result,"%u,%s", ea->type,ea->address);
 
864
                l = snprintf(result, maxSize, "%u,%s", ea->type, ea->address);
896
865
                }
897
866
                break;
898
867
        case SYN_PO_ADDRESS:{
899
868
                const NWDSChar* const* pa = (const NWDSChar* const*)val;
900
 
                int n;
901
 
                size_t len=1;
902
 
                for (n=0;n <5;n++)
903
 
                  len +=strlen(pa[n]+1);
904
 
                if (len >=maxSize)
905
 
                        return NWE_BUFFER_OVERFLOW;
906
 
                sprintf(result,"%s,%s,%s,%s,%s,%s",pa[0],pa[1],pa[2],pa[3],pa[4],pa[5]);
 
869
 
 
870
                l = snprintf(result, maxSize, "%s,%s,%s,%s,%s,%s", pa[0], pa[1], pa[2], pa[3], pa[4], pa[5]);
907
871
                }
908
872
                break;
909
873
        case SYN_HOLD:{
910
874
                const Hold_T* h = (const Hold_T*)val;
911
 
                if (strlen(h->objectName)+8+1+1>=maxSize)
912
 
                        return NWE_BUFFER_OVERFLOW;
913
 
                sprintf(result,"%u,%s", h->amount, h->objectName);
 
875
 
 
876
                l = snprintf(result, maxSize, "%u,%s", h->amount, h->objectName);
914
877
                }
915
878
                break;
916
879
         case SYN_TIMESTAMP:{
917
880
                const TimeStamp_T* stamp = (const TimeStamp_T*)val;
918
 
                if (maxSize <=3*9)
919
 
                        return NWE_BUFFER_OVERFLOW;
920
 
                sprintf(result,"%u,%u,%u",stamp->wholeSeconds, stamp->replicaNum,stamp->eventID);
 
881
                
 
882
                l = snprintf(result, maxSize, "%u,%u,%u", stamp->wholeSeconds, stamp->replicaNum, stamp->eventID);
921
883
                }
922
884
                break;
923
885
         case SYN_BACK_LINK:{
924
886
                const Back_Link_T* bl = (const Back_Link_T*)val;
925
 
                if (strlen(bl->objectName)+8+1+1 >=maxSize)
926
 
                        return NWE_BUFFER_OVERFLOW;
927
 
                sprintf(result,"%08X,%s", bl->remoteID, bl->objectName);
 
887
 
 
888
                l = snprintf(result, maxSize, "%08X,%s", bl->remoteID, bl->objectName);
928
889
                }
929
890
                break;
930
891
        case SYN_CI_LIST:{
949
910
                }
950
911
                *(--aux)=0;
951
912
                }
952
 
                break;
 
913
                return 0;
953
914
 
954
915
         case SYN_OCTET_LIST:{
955
916
                const Octet_List_T* ol = (const Octet_List_T*)val;
956
917
                size_t i;
957
 
                char aux [4];
958
 
                if ((ol->length+1)*3+1 >=maxSize)
 
918
                char *aux;
 
919
 
 
920
                if (20 + (ol->length+1)*3+1 >=maxSize)
959
921
                        return NWE_BUFFER_OVERFLOW;
960
 
                sprintf(result,"%u", ol->length);
 
922
                sprintf(result, "%u", ol->length);
 
923
                aux = result + strlen(result);
961
924
                for (i = 0; i < ol->length; i++) {
962
 
                        sprintf(aux,",%02X", ol->data[i]);
963
 
                        strcat(result,aux);
964
 
                }
965
 
                }
966
 
                break;
 
925
                        sprintf(aux, ",%02X", ol->data[i]);
 
926
                        aux += 3;
 
927
                }
 
928
                }
 
929
                return 0;
967
930
        case SYN_OCTET_STRING:{
968
931
                const Octet_String_T* os = (const Octet_String_T*)val;
969
 
                char aux [4];
970
932
                size_t i;
 
933
                char *aux;
971
934
#ifdef DEBUG_PRINT
972
935
                printf ("len %d\n",os->length);
973
936
#endif
974
 
                if ((os->length+1)*3+1 >=maxSize)
 
937
                if (20 + (os->length+1)*3+1 >=maxSize)
975
938
                        return NWE_BUFFER_OVERFLOW;
976
 
                sprintf(result,"%u", os->length);
 
939
                sprintf(result, "%u", os->length);
 
940
                aux = result + strlen(result);
977
941
                for (i = 0; i < os->length; i++) {
978
 
                        sprintf(aux,",%02X", os->data[i]);
979
 
                        strcat(result,aux);
980
 
                }
981
 
                }
982
 
                break;
 
942
                        sprintf(aux, ",%02X", os->data[i]);
 
943
                        aux += 3;
 
944
                }
 
945
                }
 
946
                return 0;
983
947
        case SYN_NET_ADDRESS:{
984
948
                const Net_Address_T* na = (const Net_Address_T*)val;
985
949
                size_t z;
986
 
                char aux[4];
 
950
                char *aux;
 
951
 
987
952
                z=na->addressLength;
988
 
                if (3*(z+2)+1  >=maxSize)
 
953
                if (40 + 3*(z+2)+1  >=maxSize)
989
954
                        return NWE_BUFFER_OVERFLOW;
990
 
                sprintf(result,"%u,%u", na->addressType,na->addressLength);
 
955
                sprintf(result, "%u,%u", na->addressType, na->addressLength);
 
956
                aux = result + strlen(result);
991
957
                for (z = 0; z < na->addressLength; z++) {
992
 
                        sprintf(aux,",%02X", na->address[z]);
993
 
                        strcat(result,aux);
994
 
                }
995
 
                }
996
 
                break;
 
958
                        sprintf(aux, ",%02X", na->address[z]);
 
959
                        aux += 3;
 
960
                }
 
961
                }
 
962
                return 0;
997
963
        case SYN_OBJECT_ACL:{
998
964
                const Object_ACL_T* oacl = (const Object_ACL_T*)val;
999
 
                if (strlen(oacl->protectedAttrName)+strlen(oacl->subjectName)+8+2+1 >=maxSize)
1000
 
                        return NWE_BUFFER_OVERFLOW;
1001
 
                sprintf(result,"%s,%s,%08X",oacl->protectedAttrName,oacl->subjectName,oacl->privileges);
 
965
 
 
966
                l = snprintf(result, maxSize, "%s,%s,%08X", oacl->protectedAttrName, oacl->subjectName, oacl->privileges);
1002
967
                }
1003
968
                break;
1004
969
        default:
1005
970
                return EINVAL;
1006
971
        }
 
972
        if (l < 0 || (size_t)l >= maxSize) {
 
973
                return NWE_BUFFER_OVERFLOW;
 
974
        }
1007
975
        return 0;
1008
976
}
1009
977
 
1016
984
 
1017
985
 
1018
986
static
1019
 
NWDSCCODE docopy_int(UNUSED(NWDSContextHandle ctx), const void * val, const enum SYNTAX synt, size_t currentSize,
 
987
NWDSCCODE docopy_int(UNUSED(NWDSContextHandle ctx), const void * val, const enum SYNTAX synt, UNUSED(size_t currentSize),
1020
988
                     void * result, size_t maxSize) {
1021
989
#ifdef DEBUG_PRINT
1022
990
        printf ("docopy_int got :%s synt = %d cursize=%d maxsize= %d\n",(char *)val,synt,currentSize,maxSize );
1136
1104
 
1137
1105
/* append the new string to a linked list */
1138
1106
static NWDSCCODE docopy_multistring(NWDSContextHandle ctx, const void * val, const enum SYNTAX synt, size_t currentSize,
1139
 
                                    void * result, size_t maxSize) {
 
1107
                                    void * result, UNUSED(size_t maxSize)) {
1140
1108
        NWDSCCODE err;
1141
1109
        char tmpBuf[MAX_DN_BYTES+1];
1142
1110
        struct strlist* l=(struct strlist *) result;
1328
1296
};
1329
1297
 
1330
1298
 
1331
 
static NWDSCCODE docopy_host_server(NWDSContextHandle ctx,
1332
 
                                    const void* val, const enum SYNTAX synt,
1333
 
                                    size_t currentSize, void* result, size_t maxSize){
 
1299
/* Note that this function is completely wrong: host server is DN, and you should use DN operations on it...
 
1300
 * Cutting it at first dot is nonsense... It might work, but there is no reason why it should... */
 
1301
static NWDSCCODE docopy_host_server(UNUSED(NWDSContextHandle ctx),
 
1302
                                    const void* val, UNUSED(const enum SYNTAX synt),
 
1303
                                    UNUSED(size_t currentSize), void* result, UNUSED(size_t maxSize)) {
1334
1304
        struct nw_home_info* hi = (struct nw_home_info*)result;
1335
1305
        char buf [MAX_DN_CHARS];
1336
1306
        char * dot;
1350
1320
        return 0;
1351
1321
}
1352
1322
 
1353
 
static NWDSCCODE docopy_host_resource_name(NWDSContextHandle ctx,
1354
 
                                    const void* val, const enum SYNTAX synt,
1355
 
                                    size_t currentSize, void* result, size_t maxSize){
 
1323
static NWDSCCODE docopy_host_resource_name(UNUSED(NWDSContextHandle ctx),
 
1324
                                    const void* val, UNUSED(const enum SYNTAX synt),
 
1325
                                    UNUSED(size_t currentSize), void* result, UNUSED(size_t maxSize)) {
1356
1326
        struct nw_home_info* hi = (struct nw_home_info*)result;
1357
1327
 
1358
1328
 
1369
1339
        return 0;
1370
1340
}
1371
1341
 
1372
 
static NWDSCCODE docopy_home_directory(NWDSContextHandle ctx,
1373
 
                                        const void* val, const enum SYNTAX synt,
1374
 
                                        size_t currentSize, void* result, size_t maxSize){
 
1342
static NWDSCCODE docopy_home_directory(UNUSED(NWDSContextHandle ctx),
 
1343
                                        const void* val, UNUSED(const enum SYNTAX synt),
 
1344
                                        UNUSED(size_t currentSize), void* result, UNUSED(size_t maxSize)) {
1375
1345
 
1376
1346
 
1377
1347
      const Path_T* pa = (const Path_T*) val;
1378
1348
      Path_T* result_int = (Path_T*)result;
1379
 
      NWDSCCODE dserr;
1380
1349
      char * v;
1381
1350
 
1382
1351