windows-cell-name-length-consistency-20080806
[openafs.git] / src / WINNT / afsd / cm_config.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <windows.h>
11 #include <winsock2.h>
12 #include <stdlib.h>
13 #include <stdio.h>
14 #include <string.h>
15
16 #include "afsd.h"
17 #include <WINNT\afssw.h>
18 #include <WINNT\afsreg.h>
19
20 #include <afs/param.h>
21 #include <afs/stds.h>
22 #include <afs/cellconfig.h>
23
24 #ifdef AFS_AFSDB_ENV
25 #include "cm_dns.h"
26 #include <afs/afsint.h>
27 #endif
28
29 static long cm_ParsePair(char *lineBufferp, char *leftp, char *rightp)
30 {
31     char *tp;
32     char tc;
33     int sawEquals;
34     int sawBracket;
35         
36     sawEquals = 0;
37     sawBracket = 0;
38     for(tp = lineBufferp; *tp; tp++) {
39         tc = *tp;
40
41         if (sawBracket) {
42             if (tc == ']')
43                 sawBracket = 0;
44             continue;
45         }
46
47         /* comment or line end */
48         if (tc == '#' || tc == '\r' || tc == '\n') 
49             break;
50
51         /* square bracket comment -- look for closing delim */
52         if (tc == '[') {
53             sawBracket = 1; 
54             continue;
55         }       
56
57         /* space or tab */
58         if (tc == ' ' || tc == '\t') 
59             continue;
60
61         if (tc == '=') {
62             sawEquals = 1;
63             continue;
64         }
65
66         /* now we have a real character, put it in the appropriate bucket */
67         if (sawEquals == 0) {
68             *leftp++ = tc;
69         }       
70         else {  
71             *rightp++ = tc;
72         }
73     }
74
75     /* null terminate the strings */
76     *leftp = 0;
77     *rightp = 0;
78
79     return 0;   /* and return success */
80 }
81
82 static int
83 IsWindowsModule(const char * name)
84 {
85     const char * p;
86     int i;
87
88     /* Do not perform searches for probable Windows modules */
89     for (p = name, i=0; *p; p++) {
90         if ( *p == '.' )
91             i++;
92     }
93     p = strrchr(name, '.');
94     if (p) {
95         if (i == 1 && 
96             (!cm_stricmp_utf8N(p,".dll") ||
97              !cm_stricmp_utf8N(p,".exe") ||
98              !cm_stricmp_utf8N(p,".ini") ||
99              !cm_stricmp_utf8N(p,".db") ||
100              !cm_stricmp_utf8N(p,".drv")))
101             return 1;
102     }
103     return 0;
104 }
105
106 /* search for a cell, and either return an error code if we don't find it,
107  * or return 0 if we do, in which case we also fill in the addresses in
108  * the cellp field.
109  *
110  * new feature:  we can handle abbreviations and are insensitive to case.
111  * If the caller wants the "real" cell name, it puts a non-null pointer in
112  * newCellNamep.  Anomaly:  if cellNamep is ambiguous, we may modify
113  * newCellNamep but return an error code.
114  *
115  * newCellNamep is required to be CELL_MAXNAMELEN+1 in size.
116  */
117 long cm_SearchCellFile(char *cellNamep, char *newCellNamep,
118                        cm_configProc_t *procp, void *rockp)
119 {
120     char wdir[MAX_PATH]="";
121     FILE *tfilep = NULL, *bestp, *tempp;
122     char *tp;
123     char lineBuffer[257];
124     struct hostent *thp;
125     char *valuep;
126     struct sockaddr_in vlSockAddr;
127     int inRightCell;
128     int foundCell = 0;
129     long code;
130     int tracking = 1, partial = 0;
131
132     if ( IsWindowsModule(cellNamep) )
133         return -3;
134
135     cm_GetCellServDB(wdir, sizeof(wdir));
136     if (*wdir)
137         tfilep = fopen(wdir, "r");
138
139     if (!tfilep) 
140         return -2;
141
142     bestp = fopen(wdir, "r");
143     
144 #ifdef CELLSERV_DEBUG
145     osi_Log2(afsd_logp,"cm_searchfile fopen handle[%p], wdir[%s]", bestp, 
146              osi_LogSaveString(afsd_logp,wdir));
147 #endif
148     /* have we seen the cell line for the guy we're looking for? */
149     inRightCell = 0;
150     while (1) {
151         tp = fgets(lineBuffer, sizeof(lineBuffer), tfilep);
152         if (tracking)
153             (void) fgets(lineBuffer, sizeof(lineBuffer), bestp);
154         if (tp == NULL) {
155             if (feof(tfilep)) {
156                 /* hit EOF */
157                 if (partial) {
158                     /*
159                      * found partial match earlier;
160                      * now go back to it
161                      */
162                     tempp = bestp;
163                     bestp = tfilep;
164                     tfilep = tempp;
165                     inRightCell = 1;
166                     partial = 0;
167                     continue;
168                 }
169                 else {
170                     fclose(tfilep);
171                     fclose(bestp);
172                     return (foundCell? 0 : -3);
173                 }
174             }
175         }       
176
177         /* turn trailing cr or lf into null */
178         tp = strchr(lineBuffer, '\r');
179         if (tp) *tp = 0;
180         tp = strchr(lineBuffer, '\n');
181         if (tp) *tp = 0;
182
183         /* skip blank lines */
184         if (lineBuffer[0] == 0) continue;
185
186         if (lineBuffer[0] == '>') {
187             /* trim off at white space or '#' chars */
188             tp = strchr(lineBuffer, ' ');
189             if (tp) *tp = 0;
190             tp = strchr(lineBuffer, '\t');
191             if (tp) *tp = 0;
192             tp = strchr(lineBuffer, '#');
193             if (tp) *tp = 0;
194
195             /* now see if this is the right cell */
196             if (stricmp(lineBuffer+1, cellNamep) == 0) {
197                 /* found the cell we're looking for */
198                 if (newCellNamep) {
199                     strncpy(newCellNamep, lineBuffer+1,CELL_MAXNAMELEN+1);
200                     newCellNamep[CELL_MAXNAMELEN] = '\0';
201                     strlwr(newCellNamep);
202                 }
203                 inRightCell = 1;
204                 tracking = 0;
205 #ifdef CELLSERV_DEBUG                
206                 osi_Log2(afsd_logp, "cm_searchfile is cell inRightCell[%p], linebuffer[%s]",
207                          inRightCell, osi_LogSaveString(afsd_logp,lineBuffer));
208 #endif
209             }
210             else if (cm_stricmp_utf8(lineBuffer+1, cellNamep) == 0) {
211                 /* partial match */
212                 if (partial) {  /* ambiguous */
213                     fclose(tfilep);
214                     fclose(bestp);
215                     return -5;
216                 }
217                 if (newCellNamep) {
218                     strncpy(newCellNamep, lineBuffer+1,CELL_MAXNAMELEN+1);
219                     newCellNamep[CELL_MAXNAMELEN] = '\0';
220                     strlwr(newCellNamep);
221                 }
222                 inRightCell = 0;
223                 tracking = 0;
224                 partial = 1;
225             }
226             else inRightCell = 0;
227         }
228         else {
229             valuep = strchr(lineBuffer, '#');
230             if (valuep == NULL) {
231                 fclose(tfilep);
232                 fclose(bestp);
233                 return -4;
234             }
235             valuep++;   /* skip the "#" */
236
237             valuep += strspn(valuep, " \t"); /* skip SP & TAB */
238             /* strip spaces and tabs in the end. They should not be there according to CellServDB format
239              * so do this just in case                        
240              */
241             while (valuep[strlen(valuep) - 1] == ' ' || valuep[strlen(valuep) - 1] == '\t') 
242                 valuep[strlen(valuep) - 1] = '\0';
243
244             if (inRightCell) {
245                 /* add the server to the VLDB list */
246                 WSASetLastError(0);
247                 thp = gethostbyname(valuep);
248 #ifdef CELLSERV_DEBUG
249                 osi_Log3(afsd_logp,"cm_searchfile inRightCell thp[%p], valuep[%s], WSAGetLastError[%d]",
250                          thp, osi_LogSaveString(afsd_logp,valuep), WSAGetLastError());
251 #endif
252                 if (thp) {
253                     memcpy(&vlSockAddr.sin_addr.s_addr, thp->h_addr,
254                             sizeof(long));
255                     vlSockAddr.sin_family = AF_INET;
256                     /* sin_port supplied by connection code */
257                     if (procp)
258                         (*procp)(rockp, &vlSockAddr, valuep);
259                     foundCell = 1;
260                 }
261                 if (!thp) {
262                     long ip_addr;
263                     int c1, c2, c3, c4;
264                     char aname[241] = "";                    
265                     
266                     /* Since there is no gethostbyname() data 
267                      * available we will read the IP address
268                      * stored in the CellServDB file
269                      */
270                     code = sscanf(lineBuffer, "%d.%d.%d.%d #%s",
271                                    &c1, &c2, &c3, &c4, aname);
272                     tp = (char *) &ip_addr;
273                     *tp++ = c1;
274                     *tp++ = c2;
275                     *tp++ = c3;
276                     *tp++ = c4;
277                     memcpy(&vlSockAddr.sin_addr.s_addr, &ip_addr,
278                             sizeof(long));
279                     vlSockAddr.sin_family = AF_INET;
280                     /* sin_port supplied by connection code */
281                     if (procp)
282                         (*procp)(rockp, &vlSockAddr, valuep);
283                     foundCell = 1;
284                 }
285             }
286         }       /* a vldb line */
287     }           /* while loop processing all lines */
288
289     /* if for some unknown reason cell is not found, return negative code (-11) ??? */
290     return (foundCell) ? 0 : -11;
291 }
292
293 /* newCellNamep is required to be CELL_MAXNAMELEN+1 in size */
294 long cm_SearchCellByDNS(char *cellNamep, char *newCellNamep, int *ttl,
295                cm_configProc_t *procp, void *rockp)
296 {
297 #ifdef AFS_AFSDB_ENV
298     int rc;
299     int  cellHostAddrs[AFSMAXCELLHOSTS];
300     char cellHostNames[AFSMAXCELLHOSTS][MAXHOSTCHARS];
301     int numServers;
302     int i;
303     struct sockaddr_in vlSockAddr;
304 #ifdef CELLSERV_DEBUG
305     osi_Log1(afsd_logp,"SearchCellDNS-Doing search for [%s]", osi_LogSaveString(afsd_logp,cellNamep));
306 #endif
307     if ( IsWindowsModule(cellNamep) )
308         return -1;
309     rc = getAFSServer(cellNamep, cellHostAddrs, cellHostNames, &numServers, ttl);
310     if (rc == 0 && numServers > 0) {     /* found the cell */
311         for (i = 0; i < numServers; i++) {
312             memcpy(&vlSockAddr.sin_addr.s_addr, &cellHostAddrs[i],
313                    sizeof(long));
314             vlSockAddr.sin_family = AF_INET;
315             /* sin_port supplied by connection code */
316             if (procp)
317                 (*procp)(rockp, &vlSockAddr, cellHostNames[i]);
318             if (newCellNamep) {
319                 strncpy(newCellNamep,cellNamep,CELL_MAXNAMELEN+1);
320                 newCellNamep[CELL_MAXNAMELEN] = '\0';
321                 strlwr(newCellNamep);
322             }
323         }
324         return 0;   /* found cell */
325     }
326     else
327        return -1;  /* not found */
328 #else
329     return -1;  /* not found */
330 #endif /* AFS_AFSDB_ENV */
331 }
332
333 /* use cm_GetConfigDir() plus AFS_CELLSERVDB to 
334  * generate the fully qualified name of the CellServDB 
335  * file.
336  */
337 long cm_GetCellServDB(char *cellNamep, afs_uint32 len)
338 {
339     size_t tlen;
340     
341     cm_GetConfigDir(cellNamep, len);
342
343     /* add trailing backslash, if required */
344     tlen = (int)strlen(cellNamep);
345     if (tlen) {
346         if (cellNamep[tlen-1] != '\\') {
347             strncat(cellNamep, "\\", len);
348             cellNamep[len-1] = '\0';
349         }
350         
351         strncat(cellNamep, AFS_CELLSERVDB, len);
352         cellNamep[len-1] = '\0';
353     }
354     return 0;
355 }
356
357 /* look up the root cell's name in the Registry */
358 long cm_GetRootCellName(char *cellNamep)
359 {
360     DWORD code, dummyLen;
361     HKEY parmKey;
362
363     code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
364                         0, KEY_QUERY_VALUE, &parmKey);
365     if (code != ERROR_SUCCESS)
366         return -1;
367
368     dummyLen = 256;
369     code = RegQueryValueEx(parmKey, "Cell", NULL, NULL,
370                                 cellNamep, &dummyLen);
371     RegCloseKey (parmKey);
372     if (code != ERROR_SUCCESS || cellNamep[0] == 0)
373         return -1;
374
375     return 0;
376 }
377
378 cm_configFile_t *cm_CommonOpen(char *namep, char *rwp)
379 {
380     char wdir[MAX_PATH]="";
381     FILE *tfilep = NULL;
382
383     cm_GetConfigDir(wdir, sizeof(wdir));
384     if (*wdir) {
385         strncat(wdir, namep, sizeof(wdir));
386         wdir[sizeof(wdir)-1] = '\0';
387         
388         tfilep = fopen(wdir, rwp);
389     }
390     return ((cm_configFile_t *) tfilep);        
391 }       
392
393 long cm_WriteConfigString(char *labelp, char *valuep)
394 {
395     DWORD code, dummyDisp;
396     HKEY parmKey;
397
398     code = RegCreateKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
399                            0, "container", 0, KEY_SET_VALUE, NULL,
400                            &parmKey, &dummyDisp);
401     if (code != ERROR_SUCCESS)
402         return -1;
403
404     code = RegSetValueEx(parmKey, labelp, 0, REG_SZ,
405                           valuep, (DWORD)strlen(valuep) + 1);
406     RegCloseKey (parmKey);
407     if (code != ERROR_SUCCESS)
408         return (long)-1;
409
410     return (long)0;
411 }
412
413 long cm_WriteConfigInt(char *labelp, long value)
414 {
415     DWORD code, dummyDisp;
416     HKEY parmKey;
417
418     code = RegCreateKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
419                            0, "container", 0, KEY_SET_VALUE, NULL,
420                            &parmKey, &dummyDisp);
421     if (code != ERROR_SUCCESS)
422         return -1;
423
424     code = RegSetValueEx(parmKey, labelp, 0, REG_DWORD,
425                           (LPBYTE)&value, sizeof(value));
426     RegCloseKey (parmKey);
427     if (code != ERROR_SUCCESS)
428         return -1;
429
430     return 0;
431 }
432
433 cm_configFile_t *cm_OpenCellFile(void)
434 {
435     cm_configFile_t *cfp;
436
437     cfp = cm_CommonOpen(AFS_CELLSERVDB ".new", "w");
438     return cfp;
439 }
440
441 long cm_AppendPrunedCellList(cm_configFile_t *ofp, char *cellNamep)
442 {
443     cm_configFile_t *tfilep;    /* input file */
444     char *tp;
445     char lineBuffer[256];
446     char *valuep;
447     int inRightCell;
448     int foundCell;
449
450     tfilep = cm_CommonOpen(AFS_CELLSERVDB, "r");
451     if (!tfilep) 
452         return -1;
453
454     foundCell = 0;
455
456     /* have we seen the cell line for the guy we're looking for? */
457     inRightCell = 0;
458     while (1) {
459         tp = fgets(lineBuffer, sizeof(lineBuffer), (FILE *)tfilep);
460         if (tp == NULL) {
461             if (feof((FILE *)tfilep)) {
462                 /* hit EOF */
463                 fclose((FILE *)tfilep);
464                 return 0;
465             }
466         }
467
468         /* turn trailing cr or lf into null */
469         tp = strchr(lineBuffer, '\r');
470         if (tp) *tp = 0;
471         tp = strchr(lineBuffer, '\n');
472         if (tp) *tp = 0;
473                 
474         /* skip blank lines */
475         if (lineBuffer[0] == 0) {
476             fprintf((FILE *)ofp, "%s\n", lineBuffer);
477             continue;
478         }
479
480         if (lineBuffer[0] == '>') {
481             /* trim off at white space or '#' chars */
482             tp = strchr(lineBuffer, ' ');
483             if (tp) *tp = 0;
484             tp = strchr(lineBuffer, '\t');
485             if (tp) *tp = 0;
486             tp = strchr(lineBuffer, '#');
487             if (tp) *tp = 0;
488
489             /* now see if this is the right cell */
490             if (strcmp(lineBuffer+1, cellNamep) == 0) {
491                 /* found the cell we're looking for */
492                 inRightCell = 1;
493             }
494             else {
495                 inRightCell = 0;
496                 fprintf((FILE *)ofp, "%s\n", lineBuffer);
497             }
498         }
499         else {
500             valuep = strchr(lineBuffer, '#');
501             if (valuep == NULL) return -2;
502             valuep++;   /* skip the "#" */
503             if (!inRightCell) {
504                 fprintf((FILE *)ofp, "%s\n", lineBuffer);
505             }
506         }       /* a vldb line */
507     }           /* while loop processing all lines */
508 }       
509
510 long cm_AppendNewCell(cm_configFile_t *filep, char *cellNamep)
511 {
512     fprintf((FILE *)filep, ">%s\n", cellNamep);
513     return 0;
514 }
515
516 long cm_AppendNewCellLine(cm_configFile_t *filep, char *linep)
517 {
518     fprintf((FILE *)filep, "%s\n", linep);
519     return 0;
520 }
521
522 long cm_CloseCellFile(cm_configFile_t *filep)
523 {
524     char wdir[MAX_PATH];
525     char sdir[MAX_PATH];
526     long code;
527     long closeCode;
528     closeCode = fclose((FILE *)filep);
529
530     cm_GetConfigDir(wdir, sizeof(wdir));
531     strcpy(sdir, wdir);
532
533     if (closeCode != 0) {
534         /* something went wrong, preserve original database */
535         strncat(wdir, AFS_CELLSERVDB ".new", sizeof(wdir));
536         wdir[sizeof(wdir)-1] = '\0';
537         unlink(wdir);
538         return closeCode;
539     }
540
541     strncat(wdir, AFS_CELLSERVDB, sizeof(wdir));
542     wdir[sizeof(wdir)-1] = '\0';
543     strncat(sdir, AFS_CELLSERVDB ".new", sizeof(sdir));/* new file */
544     sdir[sizeof(sdir)-1] = '\0';
545
546     unlink(sdir);                       /* delete old file */
547
548     code = rename(sdir, wdir);  /* do the rename */
549
550     if (code) 
551         code = errno;
552
553     return code;
554 }   
555
556 void cm_GetConfigDir(char *dir, afs_uint32 len)
557 {
558     char * dirp = NULL;
559
560     if (!afssw_GetClientCellServDBDir(&dirp)) {
561         strncpy(dir, dirp, len);
562         dir[len-1] = '\0';
563         free(dirp);
564     } else {
565         dir[0] = '\0';
566     }
567 }