4899ab06a4b0089beed01cdab43a172638fc16be
[openafs.git] / src / WINNT / afsd / cm_freelance.c
1 #include <afs/param.h>
2 #include <afs/stds.h>
3
4 #include <windows.h>
5 #include <winreg.h>
6 #include <winsock2.h>
7 #include <stdlib.h>
8 #include <malloc.h>
9 #include <string.h>
10
11 #include <WINNT/afsreg.h>
12 #include "afsd.h"
13 #include <rx/rx.h>
14
15 #ifdef AFS_FREELANCE_CLIENT
16 #include "cm_freelance.h"
17 #include "stdio.h"
18
19 extern void afsi_log(char *pattern, ...);
20
21 int cm_noLocalMountPoints;
22 char * cm_FakeRootDir = NULL;
23 int cm_fakeDirSize = 0;
24 int cm_fakeDirCallback=0;
25 int cm_fakeGettingCallback=0;
26 cm_localMountPoint_t* cm_localMountPoints;
27 osi_mutex_t cm_Freelance_Lock;
28 int cm_localMountPointChangeFlag = 0;
29 int cm_freelanceEnabled = 1;
30 time_t FakeFreelanceModTime = 0x3b49f6e2;
31
32 static int freelance_ShutdownFlag = 0;
33 static HANDLE hFreelanceChangeEvent = 0;
34 static HANDLE hFreelanceSymlinkChangeEvent = 0;
35
36 void cm_InitFakeRootDir();
37
38 void cm_FreelanceChangeNotifier(void * parmp) {
39     HKEY   hkFreelance = 0;
40
41     if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, 
42                       AFSREG_CLT_OPENAFS_SUBKEY "\\Freelance",
43                       0,
44                       KEY_NOTIFY,
45                       &hkFreelance) == ERROR_SUCCESS) {
46
47         hFreelanceChangeEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
48         if (hFreelanceChangeEvent == NULL) {
49             RegCloseKey(hkFreelance);
50             return;
51         }
52     }
53
54     while ( TRUE ) {
55     /* check hFreelanceChangeEvent to see if it is set. 
56      * if so, call cm_noteLocalMountPointChange()
57      */
58         if (RegNotifyChangeKeyValue( hkFreelance,   /* hKey */
59                                      FALSE,         /* bWatchSubtree */
60                                      REG_NOTIFY_CHANGE_LAST_SET, /* dwNotifyFilter */
61                                      hFreelanceChangeEvent, /* hEvent */
62                                      TRUE          /* fAsynchronous */
63                                      ) != ERROR_SUCCESS) {
64             RegCloseKey(hkFreelance);
65             CloseHandle(hFreelanceChangeEvent);
66             hFreelanceChangeEvent = 0;
67             return;
68         }
69
70         if (WaitForSingleObject(hFreelanceChangeEvent, INFINITE) == WAIT_OBJECT_0)
71         {
72             if (freelance_ShutdownFlag == 1) {     
73                 RegCloseKey(hkFreelance);          
74                 CloseHandle(hFreelanceChangeEvent);
75                 hFreelanceChangeEvent = 0;         
76                 return;                            
77             }                                      
78             cm_noteLocalMountPointChange();
79         }
80     }
81 }
82
83 void cm_FreelanceSymlinkChangeNotifier(void * parmp) {
84     HKEY   hkFreelance = 0;
85
86     if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, 
87                       AFSREG_CLT_OPENAFS_SUBKEY "\\Freelance\\Symlinks",
88                       0,
89                       KEY_NOTIFY,
90                       &hkFreelance) == ERROR_SUCCESS) {
91
92         hFreelanceSymlinkChangeEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
93         if (hFreelanceSymlinkChangeEvent == NULL) {
94             RegCloseKey(hkFreelance);
95             return;
96         }
97     }
98
99     while ( TRUE ) {
100     /* check hFreelanceSymlinkChangeEvent to see if it is set. 
101      * if so, call cm_noteLocalMountPointSymlinkChange()
102      */
103         if (RegNotifyChangeKeyValue( hkFreelance,   /* hKey */
104                                      FALSE,         /* bWatchSubtree */
105                                      REG_NOTIFY_CHANGE_LAST_SET, /* dwNotifyFilter */
106                                      hFreelanceSymlinkChangeEvent, /* hEvent */
107                                      TRUE          /* fAsynchronous */
108                                      ) != ERROR_SUCCESS) {
109             RegCloseKey(hkFreelance);
110             CloseHandle(hFreelanceSymlinkChangeEvent);
111             hFreelanceSymlinkChangeEvent = 0;
112             return;
113         }
114
115         if (WaitForSingleObject(hFreelanceSymlinkChangeEvent, INFINITE) == WAIT_OBJECT_0)
116         {
117             if (freelance_ShutdownFlag == 1) {     
118                 RegCloseKey(hkFreelance);          
119                 CloseHandle(hFreelanceSymlinkChangeEvent);
120                 hFreelanceSymlinkChangeEvent = 0;         
121                 return;                            
122             }                                      
123             cm_noteLocalMountPointChange();
124         }
125     }
126 }
127
128 void                                          
129 cm_FreelanceShutdown(void)                    
130 {                                             
131     freelance_ShutdownFlag = 1;               
132     if (hFreelanceChangeEvent != 0)           
133         thrd_SetEvent(hFreelanceChangeEvent); 
134     if (hFreelanceSymlinkChangeEvent != 0)           
135         thrd_SetEvent(hFreelanceSymlinkChangeEvent); 
136 }                                             
137
138 void cm_InitFreelance() {
139     thread_t phandle;
140     int lpid;
141
142     lock_InitializeMutex(&cm_Freelance_Lock, "Freelance Lock");
143
144     // yj: first we make a call to cm_initLocalMountPoints
145     // to read all the local mount points from the registry
146     cm_InitLocalMountPoints();
147
148     // then we make a call to InitFakeRootDir to create
149     // a fake root directory based on the local mount points
150     cm_InitFakeRootDir();
151     // --- end of yj code
152
153     /* Start the registry monitor */
154     phandle = thrd_Create(NULL, 65536, (ThreadFunc) cm_FreelanceChangeNotifier,
155                           NULL, 0, &lpid, "cm_FreelanceChangeNotifier");
156     osi_assertx(phandle != NULL, "cm_FreelanceChangeNotifier thread create failure");
157     thrd_CloseHandle(phandle);
158
159     phandle = thrd_Create(NULL, 65536, (ThreadFunc) cm_FreelanceSymlinkChangeNotifier,
160                           NULL, 0, &lpid, "cm_FreelanceSymlinkChangeNotifier");
161     osi_assertx(phandle != NULL, "cm_FreelanceSymlinkChangeNotifier thread create failure");
162     thrd_CloseHandle(phandle);
163 }
164
165 /* yj: Initialization of the fake root directory */
166 /* to be called while holding freelance lock unless during init. */
167 void cm_InitFakeRootDir() {
168     int i, t1, t2;
169     char* currentPos;
170     int noChunks;
171
172     // allocate space for the fake info
173     cm_dirHeader_t fakeDirHeader;
174     cm_dirEntry_t fakeEntry;
175     cm_pageHeader_t fakePageHeader;
176
177     // i'm going to calculate how much space is needed for
178     // this fake root directory. we have these rules:
179     // 1. there are cm_noLocalMountPoints number of entries
180     // 2. each page is CM_DIR_PAGESIZE in size
181     // 3. the first 13 chunks of the first page are used for
182     //    some header stuff
183     // 4. the first chunk of all subsequent pages are used
184     //    for page header stuff
185     // 5. a max of CM_DIR_EPP entries are allowed per page
186     // 6. each entry takes 1 or more chunks, depending on 
187     //    the size of the mount point string, as determined
188     //    by cm_NameEntries
189     // 7. each chunk is CM_DIR_CHUNKSIZE bytes
190
191     int CPP = CM_DIR_PAGESIZE / CM_DIR_CHUNKSIZE;
192     int curChunk = 13;  // chunks 0 - 12 are used for header stuff
193                         // of the first page in the directory
194     int curPage = 0;
195     int curDirEntry = 0;
196     int curDirEntryInPage = 0;
197     int sizeOfCurEntry;
198     int dirSize;
199
200     /* Reserve 2 directory chunks for "." and ".." */
201     curChunk += 2;
202
203     while (curDirEntry<cm_noLocalMountPoints) {
204         sizeOfCurEntry = cm_NameEntries((cm_localMountPoints+curDirEntry)->namep, 0);
205         if ((curChunk + sizeOfCurEntry >= CPP) ||
206              (curDirEntryInPage + 1 >= CM_DIR_EPP)) {
207             curPage++;
208             curDirEntryInPage = 0;
209             curChunk = 1;
210         }
211         curChunk += sizeOfCurEntry;
212         curDirEntry++;
213         curDirEntryInPage++;
214     }
215
216     dirSize = (curPage+1) *  CM_DIR_PAGESIZE;
217     if (cm_fakeDirSize != dirSize) {
218         if (cm_FakeRootDir)
219             free(cm_FakeRootDir);
220         cm_FakeRootDir = malloc(dirSize);
221         cm_fakeDirSize = dirSize;
222     }
223
224     // yj: when we get here, we've figured out how much memory we need and 
225     // allocated the appropriate space for it. we now prceed to fill
226     // it up with entries.
227     curPage = 0;
228     curDirEntry = 0;
229     curDirEntryInPage = 0;
230     curChunk = 0;
231
232     // fields in the directory entry that are unused.
233     fakeEntry.flag = 1;
234     fakeEntry.length = 0;
235     fakeEntry.next = 0;
236     fakeEntry.fid.unique = htonl(1);
237
238     // the first page is special, it uses fakeDirHeader instead of fakePageHeader
239     // we fill up the page with dirEntries that belong there and we make changes
240     // to the fakeDirHeader.header.freeBitmap along the way. Then when we're done
241     // filling up the dirEntries in this page, we copy the fakeDirHeader into 
242     // the top of the page.
243
244     // init the freeBitmap array
245     for (i=0; i<8; i++) 
246         fakeDirHeader.header.freeBitmap[i]=0;
247
248     fakeDirHeader.header.freeBitmap[0] = 0xff;
249     fakeDirHeader.header.freeBitmap[1] = 0x7f;
250
251
252     // we start counting at 13 because the 0th to 12th chunks are used for header
253     curChunk = 13;
254
255     // stick the first 2 entries "." and ".." in
256     fakeEntry.fid.vnode = htonl(1);
257     strcpy(fakeEntry.name, ".");
258     currentPos = cm_FakeRootDir + curPage * CM_DIR_PAGESIZE + curChunk * CM_DIR_CHUNKSIZE;
259     memcpy(currentPos, &fakeEntry, CM_DIR_CHUNKSIZE);
260     curChunk++; curDirEntryInPage++;
261     strcpy(fakeEntry.name, "..");
262     currentPos = cm_FakeRootDir + curPage * CM_DIR_PAGESIZE + curChunk * CM_DIR_CHUNKSIZE;
263     memcpy(currentPos, &fakeEntry, CM_DIR_CHUNKSIZE);
264     curChunk++; curDirEntryInPage++;
265
266     // keep putting stuff into page 0 if
267     // 1. we're not done with all entries
268     // 2. we have less than CM_DIR_EPP entries in page 0
269     // 3. we're not out of chunks in page 0
270
271     while( (curDirEntry<cm_noLocalMountPoints) && 
272            (curDirEntryInPage < CM_DIR_EPP) &&
273            (curChunk + cm_NameEntries((cm_localMountPoints+curDirEntry)->namep, 0) <= CPP)) 
274     {       
275
276         noChunks = cm_NameEntries((cm_localMountPoints+curDirEntry)->namep, 0);
277         fakeEntry.fid.vnode = htonl(curDirEntry + 2);
278         currentPos = cm_FakeRootDir + curPage * CM_DIR_PAGESIZE + curChunk * CM_DIR_CHUNKSIZE;
279
280         memcpy(currentPos, &fakeEntry, CM_DIR_CHUNKSIZE);
281         strcpy(currentPos + 12, (cm_localMountPoints+curDirEntry)->namep);
282         curDirEntry++;
283         curDirEntryInPage++;
284         for (i=0; i<noChunks; i++) {
285             t1 = (curChunk + i) / 8;
286             t2 = curChunk + i - (t1*8);
287             fakeDirHeader.header.freeBitmap[t1] |= (1 << t2);
288         }
289         curChunk+=noChunks;
290     }
291
292     // when we get here, we're done with filling in the entries for page 0
293     // copy in the header info
294
295     memcpy(cm_FakeRootDir, &fakeDirHeader, 13 * CM_DIR_CHUNKSIZE);
296
297     curPage++;
298
299     // ok, page 0's done. Move on to the next page.
300     while (curDirEntry<cm_noLocalMountPoints) {
301         // setup a new page
302         curChunk = 1;                   // the zeroth chunk is reserved for page header
303         curDirEntryInPage = 0; 
304         for (i=0; i<8; i++) {
305             fakePageHeader.freeBitmap[i]=0;
306         }
307         fakePageHeader.freeCount = 0;
308         fakePageHeader.pgcount = 0;
309         fakePageHeader.tag = htons(1234);
310
311         // while we're on the same page...
312         while ( (curDirEntry<cm_noLocalMountPoints) &&
313                 (curDirEntryInPage < CM_DIR_EPP) &&
314                 (curChunk + cm_NameEntries((cm_localMountPoints+curDirEntry)->namep, 0) <= CPP))
315         {
316             // add an entry to this page
317
318             noChunks = cm_NameEntries((cm_localMountPoints+curDirEntry)->namep, 0);
319             fakeEntry.fid.vnode=htonl(curDirEntry+2);
320             currentPos = cm_FakeRootDir + curPage * CM_DIR_PAGESIZE + curChunk * CM_DIR_CHUNKSIZE;
321             memcpy(currentPos, &fakeEntry, CM_DIR_CHUNKSIZE);
322             strcpy(currentPos + 12, (cm_localMountPoints+curDirEntry)->namep);
323             curDirEntry++;
324             curDirEntryInPage++;
325             for (i=0; i<noChunks; i++) {
326                 t1 = (curChunk + i) / 8;
327                 t2 = curChunk + i - (t1*8);
328                 fakePageHeader.freeBitmap[t1] |= (1 << t2);
329             }
330             curChunk+=noChunks;
331         }
332         memcpy(cm_FakeRootDir + curPage * CM_DIR_PAGESIZE, &fakePageHeader, sizeof(fakePageHeader));
333
334         curPage++;
335     }
336
337     // we know the fakeDir is setup properly, so we claim that we have callback
338     osi_Log0(afsd_logp,"cm_InitFakeRootDir fakeDirCallback=1");
339     cm_fakeDirCallback=1;
340
341     // when we get here, we've set up everything! done!
342 }
343
344 int cm_FakeRootFid(cm_fid_t *fidp)
345 {
346     cm_SetFid(fidp, 
347               AFS_FAKE_ROOT_CELL_ID,            /* root cell */
348               AFS_FAKE_ROOT_VOL_ID,            /* root.afs ? */
349               1, 1);
350     return 0;
351 }
352   
353 /* called directly from ioctl */
354 /* called while not holding freelance lock */
355 int cm_noteLocalMountPointChange(void) {
356     lock_ObtainMutex(&cm_Freelance_Lock);
357     cm_data.fakeDirVersion++;
358     cm_localMountPointChangeFlag = 1;
359     lock_ReleaseMutex(&cm_Freelance_Lock);
360     return 1;
361 }
362
363 int cm_getLocalMountPointChange() {
364     return cm_localMountPointChangeFlag;
365 }
366
367 int cm_clearLocalMountPointChange() {
368     cm_localMountPointChangeFlag = 0;
369     return 0;
370 }
371
372 int cm_reInitLocalMountPoints() {
373     cm_fid_t aFid;
374     int i, hash;
375     cm_scache_t *scp, **lscpp, *tscp;
376         
377     osi_Log0(afsd_logp,"----- freelance reinitialization starts ----- ");
378
379     // first we invalidate all the SCPs that were created
380     // for the local mount points
381
382     osi_Log0(afsd_logp,"Invalidating local mount point scp...  ");
383
384
385     lock_ObtainWrite(&cm_scacheLock);
386     lock_ObtainMutex(&cm_Freelance_Lock);  /* always scache then freelance lock */
387     for (i=1; i<=cm_noLocalMountPoints; i++) {
388         cm_SetFid(&aFid, AFS_FAKE_ROOT_CELL_ID, AFS_FAKE_ROOT_VOL_ID, i, 1);
389         hash = CM_SCACHE_HASH(&aFid);
390         for (scp=cm_data.scacheHashTablep[hash]; scp; scp=scp->nextp) {
391             if (scp != cm_data.rootSCachep && cm_FidCmp(&scp->fid, &aFid) == 0) {
392                 // mark the scp to be reused
393                 cm_HoldSCacheNoLock(scp);
394                 lock_ReleaseWrite(&cm_Freelance_Lock);
395                 lock_ReleaseWrite(&cm_scacheLock);
396                 lock_ObtainWrite(&scp->rw);
397                 cm_DiscardSCache(scp);
398
399                 // take the scp out of the hash
400                 lock_ObtainWrite(&cm_scacheLock);
401                 for (lscpp = &cm_data.scacheHashTablep[hash], tscp = cm_data.scacheHashTablep[hash]; 
402                      tscp; 
403                      lscpp = &tscp->nextp, tscp = tscp->nextp) {
404                     if (tscp == scp) {
405                         *lscpp = scp->nextp;
406                         scp->nextp = NULL;
407                         scp->flags &= ~CM_SCACHEFLAG_INHASH;
408                         break;
409                     }
410                 }
411
412                 lock_ReleaseWrite(&scp->rw);
413                 lock_ReleaseWrite(&cm_scacheLock);
414                 cm_CallbackNotifyChange(scp);
415                 lock_ObtainWrite(&cm_scacheLock);
416                 cm_ReleaseSCacheNoLock(scp);
417                 lock_ObtainMutex(&cm_Freelance_Lock);
418             }
419         }
420     }
421     lock_ReleaseWrite(&cm_scacheLock);
422     osi_Log0(afsd_logp,"\tall old scp cleared!");
423
424     // we must free the memory that was allocated in the prev
425     // cm_InitLocalMountPoints call
426     osi_Log0(afsd_logp,"Removing old localmountpoints...  ");
427     free(cm_localMountPoints);
428     osi_Log0(afsd_logp,"\tall old localmountpoints cleared!");
429
430     // now re-init the localmountpoints
431     osi_Log0(afsd_logp,"Creating new localmountpoints...  ");
432     cm_InitLocalMountPoints();
433     osi_Log0(afsd_logp,"\tcreated new set of localmountpoints!");
434
435     // then we re-create that dir
436     osi_Log0(afsd_logp,"Creating new fakedir...  ");
437     cm_InitFakeRootDir();
438     osi_Log0(afsd_logp,"\t\tcreated new fakedir!");
439
440     lock_ReleaseMutex(&cm_Freelance_Lock);
441
442     osi_Log0(afsd_logp,"----- freelance reinit complete -----");
443     return 0;
444 }
445
446
447 // yj: open up the registry and read all the local mount 
448 // points that are stored there. Part of the initialization
449 // process for the freelance client.
450 /* to be called while holding freelance lock unless during init. */
451 long cm_InitLocalMountPoints() {
452     FILE *fp;
453     int i;
454     char line[512];
455     char*t, *t2;
456     cm_localMountPoint_t* aLocalMountPoint;
457     char hdir[260];
458     long code;
459     char rootCellName[256];
460     HKEY hkFreelance = 0, hkFreelanceSymlinks = 0;
461     DWORD dwType, dwSize;
462     DWORD dwMountPoints = 0;
463     DWORD dwIndex;
464     DWORD dwSymlinks = 0;
465     FILETIME ftLastWriteTime;
466
467     if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, 
468                       AFSREG_CLT_OPENAFS_SUBKEY "\\Freelance",
469                       0,
470                       KEY_READ|KEY_WRITE|KEY_QUERY_VALUE,
471                       &hkFreelance) == ERROR_SUCCESS) {
472
473         RegQueryInfoKey( hkFreelance,
474                          NULL,  /* lpClass */
475                          NULL,  /* lpcClass */
476                          NULL,  /* lpReserved */
477                          NULL,  /* lpcSubKeys */
478                          NULL,  /* lpcMaxSubKeyLen */
479                          NULL,  /* lpcMaxClassLen */
480                          &dwMountPoints, /* lpcValues */
481                          NULL,  /* lpcMaxValueNameLen */
482                          NULL,  /* lpcMaxValueLen */
483                          NULL,  /* lpcbSecurityDescriptor */
484                          &ftLastWriteTime /* lpftLastWriteTime */
485                          );
486
487         smb_UnixTimeFromLargeSearchTime(&FakeFreelanceModTime, &ftLastWriteTime);
488
489         if ( dwMountPoints == 0 ) {
490             rootCellName[0] = '.';
491             code = cm_GetRootCellName(&rootCellName[1]);
492             if (code == 0) {
493                 cm_FreelanceAddMount(&rootCellName[1], &rootCellName[1], "root.cell.", 0, NULL);
494                 cm_FreelanceAddMount(rootCellName, &rootCellName[1], "root.cell.", 1, NULL);
495                 cm_FreelanceAddMount(".root", &rootCellName[1], "root.afs.", 1, NULL);
496                 dwMountPoints = 3;
497             }
498         }
499
500         if (RegCreateKeyEx( HKEY_LOCAL_MACHINE, 
501                           AFSREG_CLT_OPENAFS_SUBKEY "\\Freelance\\Symlinks",
502                           0,
503                           NULL,
504                           REG_OPTION_NON_VOLATILE,
505                           KEY_READ|KEY_WRITE|KEY_QUERY_VALUE,
506                           NULL,
507                           &hkFreelanceSymlinks,
508                           NULL) == ERROR_SUCCESS) {
509
510             RegQueryInfoKey( hkFreelanceSymlinks,
511                              NULL,  /* lpClass */
512                              NULL,  /* lpcClass */
513                              NULL,  /* lpReserved */
514                              NULL,  /* lpcSubKeys */
515                              NULL,  /* lpcMaxSubKeyLen */
516                              NULL,  /* lpcMaxClassLen */
517                              &dwSymlinks, /* lpcValues */
518                              NULL,  /* lpcMaxValueNameLen */
519                              NULL,  /* lpcMaxValueLen */
520                              NULL,  /* lpcbSecurityDescriptor */
521                              NULL   /* lpftLastWriteTime */
522                              );
523         }
524
525         // get the number of entries there are from the first line
526         // that we read
527         cm_noLocalMountPoints = dwMountPoints + dwSymlinks;
528
529         // create space to store the local mount points
530         cm_localMountPoints = malloc(sizeof(cm_localMountPoint_t) * cm_noLocalMountPoints);
531         aLocalMountPoint = cm_localMountPoints;
532
533         // now we read n lines and parse them into local mount points
534         // where n is the number of local mount points there are, as
535         // determined above.
536         // Each line in the ini file represents 1 local mount point and 
537         // is in the format xxx#yyy:zzz, where xxx is the directory
538         // entry name, yyy is the cell name and zzz is the volume name.
539         // #yyy:zzz together make up the mount point.
540         for ( dwIndex = 0 ; dwIndex < dwMountPoints; dwIndex++ ) {
541             TCHAR szValueName[16];
542             DWORD dwValueSize = 16;
543             dwSize = sizeof(line);
544             if (RegEnumValue( hkFreelance, dwIndex, szValueName, &dwValueSize, NULL,
545                           &dwType, line, &dwSize))
546             {
547                 afsi_log("RegEnumValue(hkFreelance) failed");
548                 cm_noLocalMountPoints--;
549                 continue;
550             }
551
552             afsi_log("Mountpoint[%d] = %s",dwIndex, line);
553
554             /* find the trailing dot; null terminate after it */
555             t2 = strrchr(line, '.');
556             if (t2)
557                 *(t2+1) = '\0';
558
559             for ( t=line;*t;t++ ) {
560                 if ( !isprint(*t) ) {
561                     afsi_log("error occurred while parsing mountpoint entry [%d]: non-printable character", dwIndex);
562                     fprintf(stderr, "error occurred while parsing mountpoint entry [%d]: non-printable character", dwIndex);
563                     cm_noLocalMountPoints--;
564                     continue;
565                 }
566             }
567
568             // line is not empty, so let's parse it
569             t = strchr(line, '#');
570             if (!t)
571                 t = strchr(line, '%');
572             // make sure that there is a '#' or '%' separator in the line
573             if (!t) {
574                 afsi_log("error occurred while parsing mountpoint entry [%d]: no # or %% separator", dwIndex);
575                 fprintf(stderr, "error occurred while parsing mountpoint entry [%d]: no # or %% separator", dwIndex);
576                 cm_noLocalMountPoints--;
577                 continue;
578             }
579
580             aLocalMountPoint->fileType = CM_SCACHETYPE_MOUNTPOINT;
581             aLocalMountPoint->namep=malloc(t-line+1);
582             strncpy(aLocalMountPoint->namep, line, t-line);
583             aLocalMountPoint->namep[t-line] = '\0';
584                 
585             /* copy the mount point string */
586             aLocalMountPoint->mountPointStringp=malloc(strlen(t));
587             strncpy(aLocalMountPoint->mountPointStringp, t, strlen(t)-1);
588             aLocalMountPoint->mountPointStringp[strlen(t)-1] = '\0';
589     
590             osi_Log2(afsd_logp,"found mount point: name %s, string %s",
591                       osi_LogSaveString(afsd_logp,aLocalMountPoint->namep),
592                       osi_LogSaveString(afsd_logp,aLocalMountPoint->mountPointStringp));
593
594             aLocalMountPoint++;
595         }
596
597         for ( dwIndex = 0 ; dwIndex < dwSymlinks; dwIndex++ ) {
598             TCHAR szValueName[16];
599             DWORD dwValueSize = 16;
600             dwSize = sizeof(line);
601             if (RegEnumValue( hkFreelanceSymlinks, dwIndex, szValueName, &dwValueSize, NULL,
602                               &dwType, line, &dwSize))
603             {
604                 afsi_log("RegEnumValue(hkFreelanceSymlinks) failed");
605                 cm_noLocalMountPoints--;
606                 continue;
607             }
608
609             afsi_log("Symlink[%d] = %s",dwIndex, line);
610
611             /* find the trailing dot; null terminate after it */
612             t2 = strrchr(line, '.');
613             if (t2)
614                 *(t2+1) = '\0';
615
616             for ( t=line;*t;t++ ) {
617                 if ( !isprint(*t) ) {
618                     afsi_log("error occurred while parsing symlink entry [%d]: non-printable character", dwIndex);
619                     fprintf(stderr, "error occurred while parsing symlink entry [%d]: non-printable character", dwIndex);
620                     cm_noLocalMountPoints--;
621                     continue;
622                 }
623             }
624
625             // line is not empty, so let's parse it
626             t = strchr(line, ':');
627
628             // make sure that there is a ':' separator in the line
629             if (!t) {
630                 afsi_log("error occurred while parsing symlink entry [%d]: no ':' separator", dwIndex);
631                 fprintf(stderr, "error occurred while parsing symlink entry [%d]: no ':' separator", dwIndex);
632                 cm_noLocalMountPoints--;
633                 continue;
634             }
635
636             aLocalMountPoint->fileType = CM_SCACHETYPE_SYMLINK;
637             aLocalMountPoint->namep=malloc(t-line+1);
638             strncpy(aLocalMountPoint->namep, line, t-line);
639             aLocalMountPoint->namep[t-line] = '\0';
640                 
641             /* copy the symlink string */
642             aLocalMountPoint->mountPointStringp=malloc(strlen(t)-1);
643             strncpy(aLocalMountPoint->mountPointStringp, t+1, strlen(t)-2);
644             aLocalMountPoint->mountPointStringp[strlen(t)-2] = '\0';
645     
646             osi_Log2(afsd_logp,"found symlink: name %s, string %s",
647                       osi_LogSaveString(afsd_logp,aLocalMountPoint->namep),
648                       osi_LogSaveString(afsd_logp,aLocalMountPoint->mountPointStringp));
649
650             aLocalMountPoint++;
651         }
652
653         if ( hkFreelanceSymlinks )
654             RegCloseKey( hkFreelanceSymlinks );
655         RegCloseKey(hkFreelance);
656         return 0;
657     }
658
659     /* What follows is the old code to read freelance mount points 
660      * out of a text file modified to copy the data into the registry
661      */
662     cm_GetConfigDir(hdir, sizeof(hdir));
663     strcat(hdir, AFS_FREELANCE_INI);
664     // open the ini file for reading
665     fp = fopen(hdir, "r");
666     if (!fp) {
667         /* look in the Windows directory where we used to store the file */
668         GetWindowsDirectory(hdir, sizeof(hdir));
669         strcat(hdir,"\\");
670         strcat(hdir, AFS_FREELANCE_INI);
671         fp = fopen(hdir, "r");
672     }
673
674     RegCreateKeyEx( HKEY_LOCAL_MACHINE, 
675                     AFSREG_CLT_OPENAFS_SUBKEY "\\Freelance",
676                     0,
677                     NULL,
678                     REG_OPTION_NON_VOLATILE,
679                     KEY_READ|KEY_WRITE,
680                     NULL,
681                     &hkFreelance,
682                     NULL);
683     dwIndex = 0;
684
685     if (!fp) {
686         RegCloseKey(hkFreelance);
687         rootCellName[0] = '.';
688         code = cm_GetRootCellName(&rootCellName[1]);
689         if (code == 0) {
690             cm_FreelanceAddMount(&rootCellName[1], &rootCellName[1], "root.cell.", 0, NULL);
691             cm_FreelanceAddMount(rootCellName, &rootCellName[1], "root.cell.", 1, NULL);
692             cm_FreelanceAddMount(".root", &rootCellName[1], "root.afs.", 1, NULL);
693         }
694         return 0;
695     }
696
697     // we successfully opened the file
698     osi_Log0(afsd_logp,"opened afs_freelance.ini");
699         
700     // now we read the first line to see how many entries
701     // there are
702     fgets(line, sizeof(line), fp);
703
704     // if the line is empty at any point when we're reading
705     // we're screwed. report error and return.
706     if (*line==0) {
707         afsi_log("error occurred while reading afs_freelance.ini");
708         fprintf(stderr, "error occurred while reading afs_freelance.ini");
709         return -1;
710     }
711
712     // get the number of entries there are from the first line
713     // that we read
714     cm_noLocalMountPoints = atoi(line);
715
716     if (cm_noLocalMountPoints > 0) {
717         // create space to store the local mount points
718         cm_localMountPoints = malloc(sizeof(cm_localMountPoint_t) * cm_noLocalMountPoints);
719         aLocalMountPoint = cm_localMountPoints;
720     }
721
722     // now we read n lines and parse them into local mount points
723     // where n is the number of local mount points there are, as
724     // determined above.
725     // Each line in the ini file represents 1 local mount point and 
726     // is in the format xxx#yyy:zzz, where xxx is the directory
727     // entry name, yyy is the cell name and zzz is the volume name.
728     // #yyy:zzz together make up the mount point.
729     for (i=0; i<cm_noLocalMountPoints; i++) {
730         fgets(line, sizeof(line), fp);
731         // check that the line is not empty
732         if (line[0]==0) {
733             afsi_log("error occurred while parsing entry in %s: empty line in line %d", AFS_FREELANCE_INI, i);
734             fprintf(stderr, "error occurred while parsing entry in afs_freelance.ini: empty line in line %d", i);
735             return -1;
736         }
737
738         /* find the trailing dot; null terminate after it */
739         t2 = strrchr(line, '.');
740         if (t2)
741             *(t2+1) = '\0';
742
743         if ( hkFreelance ) {
744             char szIndex[16];
745             /* we are migrating to the registry */
746             sprintf(szIndex,"%d",dwIndex++);
747             dwType = REG_SZ;
748             dwSize = (DWORD)strlen(line) + 1;
749             RegSetValueEx( hkFreelance, szIndex, 0, dwType, line, dwSize);
750         }
751
752         // line is not empty, so let's parse it
753         t = strchr(line, '#');
754         if (!t)
755             t = strchr(line, '%');
756         // make sure that there is a '#' or '%' separator in the line
757         if (!t) {
758             afsi_log("error occurred while parsing entry in %s: no # or %% separator in line %d", AFS_FREELANCE_INI, i);
759             fprintf(stderr, "error occurred while parsing entry in afs_freelance.ini: no # or %% separator in line %d", i);
760             return -1;
761         }
762         aLocalMountPoint->namep=malloc(t-line+1);
763         memcpy(aLocalMountPoint->namep, line, t-line);
764         *(aLocalMountPoint->namep + (t-line)) = 0;
765
766         aLocalMountPoint->mountPointStringp=malloc(strlen(line) - (t-line) + 1);
767         memcpy(aLocalMountPoint->mountPointStringp, t, strlen(line)-(t-line)-1);
768         *(aLocalMountPoint->mountPointStringp + (strlen(line)-(t-line)-1)) = 0;
769
770         osi_Log2(afsd_logp,"found mount point: name %s, string %s",
771                   aLocalMountPoint->namep,
772                   aLocalMountPoint->mountPointStringp);
773
774         aLocalMountPoint++;
775     }
776     fclose(fp);
777     if ( hkFreelance ) {
778         RegCloseKey(hkFreelance);
779         DeleteFile(hdir);
780     }
781     return 0;
782 }
783
784 int cm_getNoLocalMountPoints() {
785     return cm_noLocalMountPoints;
786 }
787
788 long cm_FreelanceMountPointExists(char * filename, int prefix_ok)
789 {
790     char* cp;
791     char line[512];
792     char shortname[200];
793     int found = 0;
794     HKEY hkFreelance = 0;
795     DWORD dwType, dwSize;
796     DWORD dwMountPoints;
797     DWORD dwIndex;
798         
799     lock_ObtainMutex(&cm_Freelance_Lock);
800
801     if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, 
802                       AFSREG_CLT_OPENAFS_SUBKEY "\\Freelance",
803                       0,
804                       KEY_READ|KEY_QUERY_VALUE,
805                       &hkFreelance) == ERROR_SUCCESS) 
806     {
807         RegQueryInfoKey( hkFreelance,
808                          NULL,  /* lpClass */
809                          NULL,  /* lpcClass */
810                          NULL,  /* lpReserved */
811                          NULL,  /* lpcSubKeys */
812                          NULL,  /* lpcMaxSubKeyLen */
813                          NULL,  /* lpcMaxClassLen */
814                          &dwMountPoints, /* lpcValues */
815                          NULL,  /* lpcMaxValueNameLen */
816                          NULL,  /* lpcMaxValueLen */
817                          NULL,  /* lpcbSecurityDescriptor */
818                          NULL   /* lpftLastWriteTime */
819                          );
820
821         for ( dwIndex = 0; dwIndex < dwMountPoints; dwIndex++ ) {
822             TCHAR szValueName[16];
823             DWORD dwValueSize = 16;
824             dwSize = sizeof(line);
825             RegEnumValue( hkFreelance, dwIndex, szValueName, &dwValueSize, NULL,
826                           &dwType, line, &dwSize);
827
828             cp=strchr(line, '#');
829             if (!cp)
830                 cp=strchr(line, '%');
831             memcpy(shortname, line, cp-line);
832             shortname[cp-line]=0;
833
834             if (!strcmp(shortname, filename)) {
835                 found = 1;
836                 break;
837             }
838         }
839         for ( dwIndex = 0; dwIndex < dwMountPoints; dwIndex++ ) {
840             TCHAR szValueName[16];
841             DWORD dwValueSize = 16;
842             dwSize = sizeof(line);
843             RegEnumValue( hkFreelance, dwIndex, szValueName, &dwValueSize, NULL,
844                           &dwType, line, &dwSize);
845
846             cp=strchr(line, '#');
847             if (!cp)
848                 cp=strchr(line, '%');
849             memcpy(shortname, line, cp-line);
850             shortname[cp-line]=0;
851
852             if (!cm_stricmp_utf8(shortname, filename)) {
853                 found = 1;
854                 break;
855             }
856
857             if (prefix_ok && strlen(shortname) - strlen(filename) == 1 && !strncmp(shortname, filename, strlen(filename))) {
858                 found = 1;
859                 break;
860             }
861         }
862         RegCloseKey(hkFreelance);
863     }
864
865     lock_ReleaseMutex(&cm_Freelance_Lock);
866
867     return found;
868 }
869
870 long cm_FreelanceSymlinkExists(char * filename, int prefix_ok)
871 {
872     char* cp;
873     char line[512];
874     char shortname[200];
875     int found = 0;
876     HKEY hkFreelance = 0;
877     DWORD dwType, dwSize;
878     DWORD dwSymlinks;
879     DWORD dwIndex;
880         
881     lock_ObtainMutex(&cm_Freelance_Lock);
882
883     if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, 
884                       AFSREG_CLT_OPENAFS_SUBKEY "\\Freelance\\Symlinks",
885                       0,
886                       KEY_READ|KEY_QUERY_VALUE,
887                       &hkFreelance) == ERROR_SUCCESS) 
888     {
889         RegQueryInfoKey( hkFreelance,
890                          NULL,  /* lpClass */
891                          NULL,  /* lpcClass */
892                          NULL,  /* lpReserved */
893                          NULL,  /* lpcSubKeys */
894                          NULL,  /* lpcMaxSubKeyLen */
895                          NULL,  /* lpcMaxClassLen */
896                          &dwSymlinks, /* lpcValues */
897                          NULL,  /* lpcMaxValueNameLen */
898                          NULL,  /* lpcMaxValueLen */
899                          NULL,  /* lpcbSecurityDescriptor */
900                          NULL   /* lpftLastWriteTime */
901                          );
902
903         for ( dwIndex = 0; dwIndex < dwSymlinks; dwIndex++ ) {
904             TCHAR szValueName[16];
905             DWORD dwValueSize = 16;
906             dwSize = sizeof(line);
907             RegEnumValue( hkFreelance, dwIndex, szValueName, &dwValueSize, NULL,
908                           &dwType, line, &dwSize);
909
910             cp=strchr(line, ':');
911             memcpy(shortname, line, cp-line);
912             shortname[cp-line]=0;
913
914             if (!strcmp(shortname, filename)) {
915                 found = 1;
916                 break;
917             }
918
919             if (prefix_ok && strlen(shortname) - strlen(filename) == 1 && !strncmp(shortname, filename, strlen(filename))) {
920                 found = 1;
921                 break;
922             }
923         }
924         for ( dwIndex = 0; dwIndex < dwSymlinks; dwIndex++ ) {
925             TCHAR szValueName[16];
926             DWORD dwValueSize = 16;
927             dwSize = sizeof(line);
928             RegEnumValue( hkFreelance, dwIndex, szValueName, &dwValueSize, NULL,
929                           &dwType, line, &dwSize);
930
931             cp=strchr(line, ':');
932             memcpy(shortname, line, cp-line);
933             shortname[cp-line]=0;
934
935             if (!cm_stricmp_utf8(shortname, filename)) {
936                 found = 1;
937                 break;
938             }
939         }
940         RegCloseKey(hkFreelance);
941     }
942
943     lock_ReleaseMutex(&cm_Freelance_Lock);
944
945     return found;
946 }
947
948 long cm_FreelanceAddMount(char *filename, char *cellname, char *volume, int rw, cm_fid_t *fidp)
949 {
950     FILE *fp;
951     char hfile[260];
952     char line[512];
953     char fullname[CELL_MAXNAMELEN];
954     int n;
955     int alias = 0;
956     HKEY hkFreelance = 0;
957     DWORD dwType, dwSize;
958     DWORD dwMountPoints;
959     DWORD dwIndex;
960
961     /* before adding, verify the cell name; if it is not a valid cell,
962        don't add the mount point.
963        allow partial matches as a means of poor man's alias. */
964     /* major performance issue? */
965     osi_Log4(afsd_logp,"Freelance Add Mount request: filename=%s cellname=%s volume=%s %s",
966               osi_LogSaveString(afsd_logp,filename), 
967               osi_LogSaveString(afsd_logp,cellname), 
968               osi_LogSaveString(afsd_logp,volume), 
969               rw ? "rw" : "ro");
970
971     if ( filename[0] == '\0' || cellname[0] == '\0' || volume[0] == '\0' )
972         return -1;
973
974     if (cellname[0] == '.') {
975         if (!cm_GetCell_Gen(&cellname[1], fullname, CM_FLAG_CREATE))
976             return -1;
977     } else {
978         if (!cm_GetCell_Gen(cellname, fullname, CM_FLAG_CREATE))
979             return -1;
980     }
981
982     if ( cm_FreelanceMountPointExists(filename, 0) ||
983          cm_FreelanceSymlinkExists(filename, 0) )
984         return -1;
985     
986     osi_Log1(afsd_logp,"Freelance Adding Mount for Cell: %s", 
987               osi_LogSaveString(afsd_logp,cellname));
988
989     lock_ObtainMutex(&cm_Freelance_Lock);
990
991     if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, 
992                       AFSREG_CLT_OPENAFS_SUBKEY "\\Freelance",
993                       0,
994                       KEY_READ|KEY_WRITE|KEY_QUERY_VALUE,
995                       &hkFreelance) == ERROR_SUCCESS) {
996
997         RegQueryInfoKey( hkFreelance,
998                          NULL,  /* lpClass */
999                          NULL,  /* lpcClass */
1000                          NULL,  /* lpReserved */
1001                          NULL,  /* lpcSubKeys */
1002                          NULL,  /* lpcMaxSubKeyLen */
1003                          NULL,  /* lpcMaxClassLen */
1004                          &dwMountPoints, /* lpcValues */
1005                          NULL,  /* lpcMaxValueNameLen */
1006                          NULL,  /* lpcMaxValueLen */
1007                          NULL,  /* lpcbSecurityDescriptor */
1008                          NULL   /* lpftLastWriteTime */
1009                          );
1010
1011         if (rw)
1012             sprintf(line, "%s%%%s:%s", filename, fullname, volume);
1013         else
1014             sprintf(line, "%s#%s:%s", filename, fullname, volume);
1015
1016         /* If we are adding a new value, there must be an unused name
1017          * within the range 0 to dwMountPoints 
1018          */
1019         for ( dwIndex = 0; dwIndex <= dwMountPoints; dwIndex++ ) {
1020             char szIndex[16];
1021             char szMount[1024];
1022
1023             dwSize = sizeof(szMount);
1024             sprintf(szIndex, "%d", dwIndex);
1025             if (RegQueryValueEx( hkFreelance, szIndex, 0, &dwType, szMount, &dwSize) != ERROR_SUCCESS) {
1026                 /* found an unused value */
1027                 dwType = REG_SZ;
1028                 dwSize = (DWORD)strlen(line) + 1;
1029                 RegSetValueEx( hkFreelance, szIndex, 0, dwType, line, dwSize);
1030                 break;
1031             } else {
1032                 int len = (int)strlen(filename);
1033                 if ( dwType == REG_SZ && !strncmp(filename, szMount, len) && 
1034                      (szMount[len] == '%' || szMount[len] == '#')) {
1035                     /* Replace the existing value */
1036                     dwType = REG_SZ;
1037                     dwSize = (DWORD)strlen(line) + 1;
1038                     RegSetValueEx( hkFreelance, szIndex, 0, dwType, line, dwSize);
1039                     break;
1040                 }
1041             }
1042         }
1043         RegCloseKey(hkFreelance);
1044     } else 
1045     {
1046         cm_GetConfigDir(hfile, sizeof(hfile));
1047         strcat(hfile, AFS_FREELANCE_INI);
1048         fp = fopen(hfile, "r+");
1049         if (!fp)
1050             return CM_ERROR_INVAL;
1051         fgets(line, sizeof(line), fp);
1052         n = atoi(line);
1053         n++;
1054         fseek(fp, 0, SEEK_SET);
1055         fprintf(fp, "%d", n);
1056         fseek(fp, 0, SEEK_END);
1057         if (rw)
1058             fprintf(fp, "%s%%%s:%s\n", filename, fullname, volume);
1059         else
1060             fprintf(fp, "%s#%s:%s\n", filename, fullname, volume);
1061         fclose(fp);
1062     }
1063     lock_ReleaseMutex(&cm_Freelance_Lock);
1064
1065     /* cm_reInitLocalMountPoints(); */
1066     if (fidp)
1067         cm_SetFid(fidp, fidp->cell, fidp->volume, ++cm_noLocalMountPoints, 1);
1068     cm_noteLocalMountPointChange();
1069     return 0;
1070 }
1071
1072 long cm_FreelanceRemoveMount(char *toremove)
1073 {
1074     int i, n;
1075     char* cp;
1076     char line[512];
1077     char shortname[200];
1078     char hfile[260], hfile2[260];
1079     FILE *fp1, *fp2;
1080     int found=0;
1081     HKEY hkFreelance = 0;
1082     DWORD dwType, dwSize;
1083     DWORD dwMountPoints;
1084     DWORD dwIndex;
1085
1086     lock_ObtainMutex(&cm_Freelance_Lock);
1087
1088     if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, 
1089                       AFSREG_CLT_OPENAFS_SUBKEY "\\Freelance",
1090                       0,
1091                       KEY_READ|KEY_WRITE|KEY_QUERY_VALUE,
1092                       &hkFreelance) == ERROR_SUCCESS) {
1093
1094         RegQueryInfoKey( hkFreelance,
1095                          NULL,  /* lpClass */
1096                          NULL,  /* lpcClass */
1097                          NULL,  /* lpReserved */
1098                          NULL,  /* lpcSubKeys */
1099                          NULL,  /* lpcMaxSubKeyLen */
1100                          NULL,  /* lpcMaxClassLen */
1101                          &dwMountPoints, /* lpcValues */
1102                          NULL,  /* lpcMaxValueNameLen */
1103                          NULL,  /* lpcMaxValueLen */
1104                          NULL,  /* lpcbSecurityDescriptor */
1105                          NULL   /* lpftLastWriteTime */
1106                          );
1107
1108         for ( dwIndex = 0; dwIndex < dwMountPoints; dwIndex++ ) {
1109             TCHAR szValueName[16];
1110             DWORD dwValueSize = 16;
1111             dwSize = sizeof(line);
1112             RegEnumValue( hkFreelance, dwIndex, szValueName, &dwValueSize, NULL,
1113                           &dwType, line, &dwSize);
1114
1115             cp=strchr(line, '#');
1116             if (!cp)
1117                 cp=strchr(line, '%');
1118             memcpy(shortname, line, cp-line);
1119             shortname[cp-line]=0;
1120
1121             if (!strcmp(shortname, toremove)) {
1122                 RegDeleteValue( hkFreelance, szValueName );
1123                 found = 1;
1124                 break;
1125             }
1126         }
1127         RegCloseKey(hkFreelance);
1128     } else 
1129     {
1130         cm_GetConfigDir(hfile, sizeof(hfile));
1131         strcat(hfile, AFS_FREELANCE_INI);
1132         strcpy(hfile2, hfile);
1133         strcat(hfile2, "2");
1134         fp1=fopen(hfile, "r+");
1135         if (!fp1)
1136             return CM_ERROR_INVAL;
1137         fp2=fopen(hfile2, "w+");
1138         if (!fp2) {
1139             fclose(fp1);
1140             return CM_ERROR_INVAL;
1141         }
1142
1143         fgets(line, sizeof(line), fp1);
1144         n=atoi(line);
1145         fprintf(fp2, "%d\n", n-1);
1146
1147         for (i=0; i<n; i++) {
1148             fgets(line, sizeof(line), fp1);
1149             cp=strchr(line, '#');
1150             if (!cp)
1151                 cp=strchr(line, '%');
1152             memcpy(shortname, line, cp-line);
1153             shortname[cp-line]=0;
1154
1155             if (strcmp(shortname, toremove)==0) {
1156
1157             } else {
1158                 found = 1;
1159                 fputs(line, fp2);
1160             }
1161         }
1162
1163         fclose(fp1);
1164         fclose(fp2);
1165         if (found) {
1166             unlink(hfile);
1167             rename(hfile2, hfile);
1168         }
1169     }
1170     
1171     lock_ReleaseMutex(&cm_Freelance_Lock);
1172     if (found) {
1173         cm_noteLocalMountPointChange();
1174         return 0;
1175     } else
1176         return CM_ERROR_NOSUCHFILE;
1177 }
1178
1179 long cm_FreelanceAddSymlink(char *filename, char *destination, cm_fid_t *fidp)
1180 {
1181     char line[512];
1182     char fullname[CELL_MAXNAMELEN];
1183     int alias = 0;
1184     HKEY hkFreelanceSymlinks = 0;
1185     DWORD dwType, dwSize;
1186     DWORD dwSymlinks;
1187     DWORD dwIndex;
1188
1189     /* before adding, verify the filename.  If it is already in use, either as 
1190      * as mount point or a cellname, do not permit the creation of the symlink.
1191      */
1192     osi_Log2(afsd_logp,"Freelance Add Symlink request: filename=%s destination=%s",
1193               osi_LogSaveString(afsd_logp,filename), 
1194               osi_LogSaveString(afsd_logp,destination));
1195     
1196     if ( filename[0] == '\0' || destination[0] == '\0' )
1197         return CM_ERROR_INVAL;
1198
1199     fullname[0] = '\0';
1200     if (filename[0] == '.') {
1201         cm_GetCell_Gen(&filename[1], fullname, CM_FLAG_CREATE);
1202         if (cm_stricmp_utf8(&filename[1],fullname) == 0)
1203             return CM_ERROR_EXISTS;
1204     } else {
1205         cm_GetCell_Gen(filename, fullname, CM_FLAG_CREATE);
1206         if (cm_stricmp_utf8(filename,fullname) == 0)
1207             return CM_ERROR_EXISTS;
1208     }
1209
1210     if ( cm_FreelanceMountPointExists(filename, 0) ||
1211          cm_FreelanceSymlinkExists(filename, 0) )
1212         return CM_ERROR_EXISTS;
1213
1214     lock_ObtainMutex(&cm_Freelance_Lock);
1215
1216     if (RegCreateKeyEx( HKEY_LOCAL_MACHINE, 
1217                         AFSREG_CLT_OPENAFS_SUBKEY "\\Freelance\\Symlinks",
1218                         0,
1219                         NULL,
1220                         REG_OPTION_NON_VOLATILE,
1221                         KEY_READ|KEY_WRITE|KEY_QUERY_VALUE,
1222                         NULL,
1223                         &hkFreelanceSymlinks,
1224                         NULL) == ERROR_SUCCESS) {
1225
1226         RegQueryInfoKey( hkFreelanceSymlinks,
1227                          NULL,  /* lpClass */
1228                          NULL,  /* lpcClass */
1229                          NULL,  /* lpReserved */
1230                          NULL,  /* lpcSubKeys */
1231                          NULL,  /* lpcMaxSubKeyLen */
1232                          NULL,  /* lpcMaxClassLen */
1233                          &dwSymlinks, /* lpcValues */
1234                          NULL,  /* lpcMaxValueNameLen */
1235                          NULL,  /* lpcMaxValueLen */
1236                          NULL,  /* lpcbSecurityDescriptor */
1237                          NULL   /* lpftLastWriteTime */
1238                          );
1239
1240         sprintf(line, "%s:%s.", filename, destination);
1241
1242         /* If we are adding a new value, there must be an unused name
1243          * within the range 0 to dwSymlinks 
1244          */
1245         for ( dwIndex = 0; dwIndex <= dwSymlinks; dwIndex++ ) {
1246             char szIndex[16];
1247             char szLink[1024];
1248
1249             dwSize = sizeof(szLink);
1250             sprintf(szIndex, "%d", dwIndex);
1251             if (RegQueryValueEx( hkFreelanceSymlinks, szIndex, 0, &dwType, szLink, &dwSize) != ERROR_SUCCESS) {
1252                 /* found an unused value */
1253                 dwType = REG_SZ;
1254                 dwSize = (DWORD)strlen(line) + 1;
1255                 RegSetValueEx( hkFreelanceSymlinks, szIndex, 0, dwType, line, dwSize);
1256                 break;
1257             } else {
1258                 int len = (int)strlen(filename);
1259                 if ( dwType == REG_SZ && !strncmp(filename, szLink, len) && szLink[len] == ':') {
1260                     /* Replace the existing value */
1261                     dwType = REG_SZ;
1262                     dwSize = (DWORD)strlen(line) + 1;
1263                     RegSetValueEx( hkFreelanceSymlinks, szIndex, 0, dwType, line, dwSize);
1264                     break;
1265                 }
1266             }
1267         }
1268         RegCloseKey(hkFreelanceSymlinks);
1269     } 
1270     lock_ReleaseMutex(&cm_Freelance_Lock);
1271
1272     /* cm_reInitLocalMountPoints(); */
1273     if (fidp)
1274         cm_SetFid(fidp, fidp->cell, fidp->volume, ++cm_noLocalMountPoints, 1);
1275     cm_noteLocalMountPointChange();
1276     return 0;
1277 }
1278
1279 long cm_FreelanceRemoveSymlink(char *toremove)
1280 {
1281     char* cp;
1282     char line[512];
1283     char shortname[200];
1284     int found=0;
1285     HKEY hkFreelanceSymlinks = 0;
1286     DWORD dwType, dwSize;
1287     DWORD dwSymlinks;
1288     DWORD dwIndex;
1289
1290     lock_ObtainMutex(&cm_Freelance_Lock);
1291
1292     if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, 
1293                       AFSREG_CLT_OPENAFS_SUBKEY "\\Freelance\\Symlinks",
1294                       0,
1295                       KEY_READ|KEY_WRITE|KEY_QUERY_VALUE,
1296                       &hkFreelanceSymlinks) == ERROR_SUCCESS) {
1297
1298         RegQueryInfoKey( hkFreelanceSymlinks,
1299                          NULL,  /* lpClass */
1300                          NULL,  /* lpcClass */
1301                          NULL,  /* lpReserved */
1302                          NULL,  /* lpcSubKeys */
1303                          NULL,  /* lpcMaxSubKeyLen */
1304                          NULL,  /* lpcMaxClassLen */
1305                          &dwSymlinks, /* lpcValues */
1306                          NULL,  /* lpcMaxValueNameLen */
1307                          NULL,  /* lpcMaxValueLen */
1308                          NULL,  /* lpcbSecurityDescriptor */
1309                          NULL   /* lpftLastWriteTime */
1310                          );
1311
1312         for ( dwIndex = 0; dwIndex < dwSymlinks; dwIndex++ ) {
1313             TCHAR szValueName[16];
1314             DWORD dwValueSize = 16;
1315             dwSize = sizeof(line);
1316             RegEnumValue( hkFreelanceSymlinks, dwIndex, szValueName, &dwValueSize, NULL,
1317                           &dwType, line, &dwSize);
1318
1319             cp=strchr(line, ':');
1320             memcpy(shortname, line, cp-line);
1321             shortname[cp-line]=0;
1322
1323             if (!strcmp(shortname, toremove)) {
1324                 RegDeleteValue( hkFreelanceSymlinks, szValueName );
1325                 found = 1;
1326                 break;
1327             }
1328         }
1329         RegCloseKey(hkFreelanceSymlinks);
1330     }
1331     
1332     lock_ReleaseMutex(&cm_Freelance_Lock);
1333     if (found) {
1334         cm_noteLocalMountPointChange();
1335         return 0;
1336     } else
1337         return CM_ERROR_NOSUCHFILE;
1338 }
1339 #endif /* AFS_FREELANCE_CLIENT */