server-list-and-volume-updates-20040730
[openafs.git] / src / WINNT / afsd / cm_cell.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 <afs/param.h>
11 #include <afs/stds.h>
12
13 #ifndef DJGPP
14 #include <windows.h>
15 #include <nb30.h>
16 #include <winsock2.h>
17 #endif /* !DJGPP */
18 #include <stdlib.h>
19 #include <stdio.h>
20 #include <malloc.h>
21 #include <osi.h>
22 #include <string.h>
23
24 #include "afsd.h"
25
26 osi_rwlock_t cm_cellLock;
27
28 cm_cell_t *cm_allCellsp;
29
30 /* function called as callback proc from cm_SearchCellFile.  Return 0 to
31  * continue processing.
32  */
33 long cm_AddCellProc(void *rockp, struct sockaddr_in *addrp, char *namep)
34 {
35         cm_server_t *tsp;
36         cm_serverRef_t *tsrp;
37     cm_cell_t *cellp;
38         
39         cellp = rockp;
40
41         /* if this server was previously created by fs setserverprefs */
42         if ( tsp = cm_FindServer(addrp, CM_SERVER_VLDB))
43         {
44                 if ( !tsp->cellp )
45                         tsp->cellp = cellp;
46         }
47         else
48         tsp = cm_NewServer(addrp, CM_SERVER_VLDB, cellp);
49
50         /* Insert the vlserver into a sorted list, sorted by server rank */
51         tsrp = cm_NewServerRef(tsp);
52         cm_InsertServerList(&cellp->vlServersp, tsrp);
53     /* drop the allocation reference */
54     lock_ObtainWrite(&cm_serverLock);
55     tsrp->refCount--;
56     lock_ReleaseWrite(&cm_serverLock);
57         return 0;
58 }
59
60 /* load up a cell structure from the cell database, afsdcell.ini */
61 cm_cell_t *cm_GetCell(char *namep, long flags)
62 {
63   return cm_GetCell_Gen(namep, NULL, flags);
64 }
65
66 cm_cell_t *cm_GetCell_Gen(char *namep, char *newnamep, long flags)
67 {
68         cm_cell_t *cp;
69     long code;
70     static cellCounter = 1;             /* locked by cm_cellLock */
71         int ttl;
72         char fullname[200]="";
73
74         if (!strcmp(namep,SMB_IOCTL_FILENAME_NOSLASH))
75                 return NULL;
76
77         lock_ObtainWrite(&cm_cellLock);
78         for (cp = cm_allCellsp; cp; cp=cp->nextp) {
79                 if (strcmp(namep, cp->namep) == 0) {
80             strcpy(fullname, cp->namep);
81             break;
82                 }
83     }
84
85         if ((!cp && (flags & CM_FLAG_CREATE))
86 #ifdef AFS_AFSDB_ENV
87          /* if it's from DNS, see if it has expired */
88          || (cp && (cp->flags & CM_CELLFLAG_DNS) 
89          && ((cp->flags & CM_CELLFLAG_VLSERVER_INVALID) || (time(0) > cp->timeout)))
90 #endif
91           ) {
92         int dns_expired = 0;
93                 if (!cp) {
94             cp = malloc(sizeof(cm_cell_t));
95             memset(cp, 0, sizeof(cm_cell_t));
96         } 
97         else {
98             dns_expired = 1;
99             /* must empty cp->vlServersp */
100             cm_FreeServerList(&cp->vlServersp);
101             cp->vlServersp = NULL;
102         }
103
104         code = cm_SearchCellFile(namep, fullname, cm_AddCellProc, cp);
105                 if (code) {
106             afsi_log("in cm_GetCell_gen cm_SearchCellFile(%s) returns code= %d fullname= %s", 
107                       namep, code, fullname);
108
109 #ifdef AFS_AFSDB_ENV
110             if (cm_dnsEnabled /*&& cm_DomainValid(namep)*/) {
111                 code = cm_SearchCellByDNS(namep, fullname, &ttl, cm_AddCellProc, cp);
112                 if ( code ) {
113                     afsi_log("in cm_GetCell_gen cm_SearchCellByDNS(%s) returns code= %d fullname= %s", 
114                              namep, code, fullname);
115                     if (dns_expired) {
116                         cp->flags |= CM_CELLFLAG_VLSERVER_INVALID;
117                         cp = NULL;  /* set cp to NULL to indicate error */
118                         goto done;
119                     } 
120                 }
121                 else {   /* got cell from DNS */
122                     cp->flags |= CM_CELLFLAG_DNS;
123                     cp->flags &= ~CM_CELLFLAG_VLSERVER_INVALID;
124                     cp->timeout = time(0) + ttl;
125                 }
126             }
127 #endif
128             if (cp && code) {     /* free newly allocated memory */
129                 free(cp);
130                 cp = NULL;
131                 goto done;
132             }
133                 }
134
135                 /* randomise among those vlservers having the same rank*/ 
136         cm_RandomizeServer(&cp->vlServersp);
137
138 #ifdef AFS_AFSDB_ENV
139         if (dns_expired) {
140             /* we want to preserve the full name and mutex.
141              * also, cp is already in the cm_allCellsp list
142              */
143             goto done;
144         }
145 #endif /* AFS_AFSDB_ENV */
146
147         /* otherwise we found the cell, and so we're nearly done */
148         lock_InitializeMutex(&cp->mx, "cm_cell_t mutex");
149
150                 /* copy in name */
151         cp->namep = malloc(strlen(fullname)+1);
152         strcpy(cp->namep, fullname);
153
154                 /* thread on global list */
155         cp->nextp = cm_allCellsp;
156         cm_allCellsp = cp;
157                 
158         cp->cellID = cellCounter++;
159     }
160
161   done:
162     /* fullname is not valid if cp == NULL */
163         if (cp && newnamep)
164         strcpy(newnamep, fullname);
165         lock_ReleaseWrite(&cm_cellLock);
166     return cp;
167 }
168
169 cm_cell_t *cm_FindCellByID(long cellID)
170 {
171         cm_cell_t *cp;
172         int ttl;
173     int code;
174
175         lock_ObtainWrite(&cm_cellLock);
176         for(cp = cm_allCellsp; cp; cp=cp->nextp) {
177                 if (cellID == cp->cellID) 
178             break;
179     }
180
181 #ifdef AFS_AFSDB_ENV
182         /* if it's from DNS, see if it has expired */
183         if (cp && cm_dnsEnabled && (cp->flags & CM_CELLFLAG_DNS) && 
184         ((cp->flags & CM_CELLFLAG_VLSERVER_INVALID) || (time(0) > cp->timeout))) {
185         /* must empty cp->vlServersp */
186         cm_FreeServerList(&cp->vlServersp);
187         cp->vlServersp = NULL;
188
189         code = cm_SearchCellByDNS(cp->namep, NULL, &ttl, cm_AddCellProc, cp);
190         if (code == 0) {   /* got cell from DNS */
191             cp->flags |= CM_CELLFLAG_DNS;
192             cp->flags &= ~CM_CELLFLAG_VLSERVER_INVALID;
193 #ifdef DEBUG
194             fprintf(stderr, "cell %s: ttl=%d\n", cp->namep, ttl);
195 #endif
196             cp->timeout = time(0) + ttl;
197         } else {
198             cp->flags |= CM_CELLFLAG_VLSERVER_INVALID;
199             cp = NULL;      /* return NULL to indicate failure */
200         }
201         /* if we fail to find it this time, we'll just do nothing and leave the
202          * current entry alone 
203          */
204         }
205 #endif /* AFS_AFSDB_ENV */
206
207         lock_ReleaseWrite(&cm_cellLock);        
208     return cp;
209 }
210
211 void cm_InitCell(void)
212 {
213         static osi_once_t once;
214         
215     if (osi_Once(&once)) {
216                 lock_InitializeRWLock(&cm_cellLock, "cell global lock");
217         cm_allCellsp = NULL;
218                 osi_EndOnce(&once);
219     }
220 }
221 void cm_ChangeRankCellVLServer(cm_server_t *tsp)
222 {
223         cm_cell_t *cp;
224         int code;
225
226         cp = tsp->cellp;        /* cell that this vlserver belongs to */
227         osi_assert(cp);
228
229         lock_ObtainMutex(&cp->mx);
230         code = cm_ChangeRankServer(&cp->vlServersp, tsp);
231
232         if ( !code )            /* if the server list was rearranged */
233             cm_RandomizeServer(&cp->vlServersp);
234
235         lock_ReleaseMutex(&cp->mx);
236 }
237