source/smbd/dfs.c

   1
   2 #include "includes.h"
   3
   4 extern int DEBUGLEVEL;
   5
   6 dfs_internal dfs_struct;
   7 extern pstring global_myname;
   8
   9 /****************************************************************************
  10 read a line and split it
  11 ****************************************************************************/
  12 static BOOL parse_dfs_text_entry(char *line, dfs_internal_table *buf)
  13 {
  14 #define MAXTOK 4
  15         char *tok[MAXTOK+1];
  16         int count = 0;
  17
  18         tok[count] = strtok(line,":");
  19
  20         /* strip the comment lines */
  21         if (tok[0][0] == '#') return (False);
  22         count++;
  23
  24         while ( ((tok[count] = strtok(NULL,":")) != NULL ) && count < MAXTOK)
  25         {
  26                 count++;
  27         }
  28
  29         DEBUG(7,("Found [%d] tokens\n", count));
  30
  31         if (count > 1) {
  32                 StrnCpy(buf->localpath, tok[0], sizeof(buf->localpath)-1);
  33                 StrnCpy(buf->sharename, tok[1], sizeof(buf->sharename)-1);
  34 /*
  35                 strupper(buf->localpath);
  36                 strupper(buf->sharename);
  37 */
  38                 buf->localpath_length = strlen(buf->localpath);
  39                 buf->sharename_length = strlen(buf->sharename);
  40         }
  41         else
  42                 return (False);
  43
  44         if (count > 2)
  45                 buf->proximity = atoi(tok[2]);
  46         else
  47                 buf->proximity = 0;
  48
  49         if (count > 3)
  50                 buf->type = atoi(tok[3]);
  51         else
  52                 buf->type = 2;
  53
  54         DEBUGADD(7,("localpath: [%s]\n", buf->localpath));
  55         DEBUGADD(7,("sharename: [%s]\n", buf->sharename));
  56         return True;
  57 }
  58
  59 /****************************************************************************
  60 mangle the localpath and store it.
  61 ****************************************************************************/
  62 static void mangle_dfs_path(dfs_internal_table *buf)
  63 {
  64         char *p;
  65         char *mp;
  66         char *q;
  67         int mlen;
  68
  69         fstring temp;
  70
  71         p = buf->localpath;
  72         mp = buf->mangledpath;
  73         mlen = sizeof(buf->mangledpath);
  74
  75         ZERO_STRUCTP(mp);
  76         DEBUG(2, ("DFS name is: [%s]\n", buf->localpath));
  77
  78         /* copy the head: \server-name\ */
  79         q = strchr(p + 1, '\\');
  80         safe_strcpy(mp, p, mlen);
  81         p = q + 1;
  82
  83         while (q != NULL)
  84         {
  85                 q = strchr(p, '\\');
  86
  87                 safe_strcpy(temp, p, sizeof(temp));
  88
  89                 if (!is_8_3(temp, True))
  90                 {
  91                         mangle_name_83(temp);
  92                 }
  93
  94                 safe_strcat(mp, temp, mlen);
  95
  96                 if (q != NULL)
  97                 {
  98                         safe_strcat(mp, "\\", mlen);
  99                 }
 100                 p = q + 1;
 101         }
 102
 103 /*
 104         strupper(mp);
 105 */
 106         buf->mangledpath_length = strlen(mp);
 107         DEBUGADD(2, ("DFS mangled name is: [%s]\n", mp));
 108 }
 109
 110 /****************************************************************************
 111 initialisation de la table dfs en memoire au demarrage de samba
 112 ****************************************************************************/
 113 BOOL init_dfs_table(void)
 114 {
 115         char *file = lp_dfs_map();
 116         int num_lines = 0;
 117         int total = 0;
 118         FILE *f;
 119         pstring line;
 120         int i;
 121
 122         dfs_internal_table *entry;
 123
 124         entry = NULL;
 125         dfs_struct.ready = False;
 126
 127         if (*file == '\0') {
 128                 DEBUG(0,("No DFS map, Samba is running in NON DFS mode\n"));
 129                 return False;
 130         }
 131
 132         f = sys_fopen(file, "r");
 133         if (!f) {
 134                 DEBUG(0,("No DFS map file, Samba is running in NON DFS mode\n"));
 135                 return False;
 136         }
 137
 138         while ( fgets(line, sizeof(pstring), f) )
 139         {
 140                 entry = Realloc(entry,sizeof(dfs_internal_table)*(total+1));
 141                 if (! entry)
 142                 {
 143                         total = 0;
 144                         break;
 145                 }
 146
 147                 if ( parse_dfs_text_entry(line, &(entry[total]) ) )
 148                 {
 149                         total++;
 150                 }
 151                 num_lines++;
 152         }
 153         dfs_struct.size = total;
 154         dfs_struct.table = entry;
 155         fclose(f);
 156
 157         /* we have the file in memory */
 158         /* now initialise the mangled names */
 159         for (i = 0; i < total; i++)
 160         {
 161                 mangle_dfs_path(&(entry[i]));
 162         }
 163
 164         dfs_struct.ready = True;
 165         DEBUG(0,("Samba is DFS aware now!\n"));
 166         return True;
 167 }
 168
 169 static BOOL check_dfs_path(int search_len, const char *search_path,
 170                 int path_len, const char* fullpath,
 171                 const char* sharename,
 172                 const char* share_path, size_t share_len,
 173                 char *localpath, size_t local_plen)
 174 {
 175         if (StrnCaseCmp(search_path, fullpath, search_len) != 0)
 176         {
 177                 return False;
 178         }
 179
 180         DEBUG(2,("found one linked to [%s]. share_path: %s\n",
 181                 sharename, share_path));
 182
 183         if (StrnCaseCmp(fullpath, share_path, share_len) == 0)
 184         {
 185                 safe_strcpy(localpath, fullpath + share_len, local_plen);
 186         }
 187         else
 188         {
 189                 localpath[0] = 0;
 190         }
 191
 192         return True;
 193 }
 194
 195 /****************************************************************************
 196  check if a path name is a DFS branch
 197 ****************************************************************************/
 198 int under_dfs(connection_struct *conn, const char *path,
 199                                 char *local_path, size_t local_plen)
 200 {
 201         fstring fullpath;
 202         pstring share_path;
 203         int i;
 204         int snum;
 205
 206         int path_len;
 207         int share_len;
 208
 209         dfs_internal_table *list = dfs_struct.table;
 210
 211         snum = SNUM(conn);
 212         snprintf(share_path, sizeof(share_path), "\\%s\\%s",
 213                            global_myname, lp_servicename(snum));
 214         share_len = strlen(share_path);
 215
 216         if (path[0] != '\\')
 217         {
 218                 snprintf(fullpath, sizeof(fullpath), "%s\\%s",
 219                            share_path, path);
 220         }
 221         else
 222         {
 223                 safe_strcpy(fullpath, path, sizeof(fullpath));
 224         }
 225
 226         path_len = strlen(fullpath);
 227
 228         DEBUG(2,("DFS looking for: [%s]\n", fullpath));
 229
 230         for (i = 0; i < dfs_struct.size; i++)
 231         {
 232                 DEBUG(6,("checking against [%s][%d]\n", list[i].localpath,i));
 233
 234                 if (check_dfs_path(list[i].localpath_length,
 235                                    list[i].localpath,
 236                                    path_len, fullpath,
 237                                    list[i].sharename,
 238                                    share_path, share_len,
 239                                    local_path, local_plen))
 240                 {
 241                         return True;
 242                 }
 243
 244                 if (check_dfs_path(list[i].mangledpath_length,
 245                                    list[i].mangledpath,
 246                                    path_len, fullpath,
 247                                    list[i].sharename,
 248                                    share_path, share_len,
 249                                    local_path, local_plen))
 250                 {
 251                         return True;
 252                 }
 253         }
 254         return False;
 255 }