source3/smbwrapper/shared.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 2.0
   4    SMB wrapper functions - shared variables
   5    Copyright (C) Andrew Tridgell 1998
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 static int shared_fd;
  25 static char *variables;
  26 static int shared_size;
  27
  28 /*****************************************************
  29 setup the shared area
  30 *******************************************************/
  31 void smbw_setup_shared(void)
  32 {
  33         int fd;
  34         pstring name, s;
  35
  36         slprintf(name,sizeof(name)-1, "%s/smbw.XXXXXX",tmpdir());
  37
  38         fd = smb_mkstemp(name);
  39
  40         if (fd == -1) goto failed;
  41
  42         unlink(name);
  43
  44         shared_fd = set_maxfiles(SMBW_MAX_OPEN);
  45
  46         while (shared_fd && dup2(fd, shared_fd) != shared_fd) shared_fd--;
  47
  48         if (shared_fd == 0) goto failed;
  49
  50         close(fd);
  51
  52         DEBUG(4,("created shared_fd=%d\n", shared_fd));
  53
  54         slprintf(s,sizeof(s)-1,"%d", shared_fd);
  55
  56         smbw_setenv("SMBW_HANDLE", s);
  57
  58         return;
  59
  60  failed:
  61         perror("Failed to setup shared variable area ");
  62         exit(1);
  63 }
  64
  65 static int locked;
  66
  67 /*****************************************************
  68 lock the shared variable area
  69 *******************************************************/
  70 static void lockit(void)
  71 {
  72         if (shared_fd == 0) {
  73                 char *p = getenv("SMBW_HANDLE");
  74                 if (!p) {
  75                         DEBUG(0,("ERROR: can't get smbw shared handle\n"));
  76                         exit(1);
  77                 }
  78                 shared_fd = atoi(p);
  79         }
  80         if (locked==0 &&
  81             fcntl_lock(shared_fd,SMB_F_SETLKW,0,1,F_WRLCK)==False) {
  82                 DEBUG(0,("ERROR: can't get smbw shared lock (%s)\n", strerror(errno)));
  83                 exit(1);
  84         }
  85         locked++;
  86 }
  87
  88 /*****************************************************
  89 unlock the shared variable area
  90 *******************************************************/
  91 static void unlockit(void)
  92 {
  93         locked--;
  94         if (locked == 0) {
  95                 fcntl_lock(shared_fd,SMB_F_SETLK,0,1,F_UNLCK);
  96         }
  97 }
  98
  99
 100 /*****************************************************
 101 get a variable from the shared area
 102 *******************************************************/
 103 char *smbw_getshared(const char *name)
 104 {
 105         int i;
 106         struct stat st;
 107         char *var;
 108
 109         lockit();
 110
 111         /* maybe the area has changed */
 112         if (fstat(shared_fd, &st)) goto failed;
 113
 114         if (st.st_size != shared_size) {
 115                 var = (char *)Realloc(variables, st.st_size);
 116                 if (!var) goto failed;
 117                 else variables = var;
 118                 shared_size = st.st_size;
 119                 lseek(shared_fd, 0, SEEK_SET);
 120                 if (read(shared_fd, variables, shared_size) != shared_size) {
 121                         goto failed;
 122                 }
 123         }
 124
 125         unlockit();
 126
 127         i=0;
 128         while (i < shared_size) {
 129                 char *n, *v;
 130                 int l1, l2;
 131
 132                 l1 = SVAL(&variables[i], 0);
 133                 l2 = SVAL(&variables[i], 2);
 134
 135                 n = &variables[i+4];
 136                 v = &variables[i+4+l1];
 137                 i += 4+l1+l2;
 138
 139                 if (strcmp(name,n)) {
 140                         continue;
 141                 }
 142                 return v;
 143         }
 144
 145         return NULL;
 146
 147  failed:
 148         DEBUG(0,("smbw: shared variables corrupt (%s)\n", strerror(errno)));
 149         exit(1);
 150         return NULL;
 151 }
 152
 153
 154
 155 /*****************************************************
 156 set a variable in the shared area
 157 *******************************************************/
 158 void smbw_setshared(const char *name, const char *val)
 159 {
 160         int l1, l2;
 161         char *var;
 162
 163         /* we don't allow variable overwrite */
 164         if (smbw_getshared(name)) return;
 165
 166         lockit();
 167
 168         l1 = strlen(name)+1;
 169         l2 = strlen(val)+1;
 170
 171         var = (char *)Realloc(variables, shared_size + l1+l2+4);
 172
 173         if (!var) {
 174                 DEBUG(0,("out of memory in smbw_setshared\n"));
 175                 exit(1);
 176         }
 177
 178         variables = var;
 179
 180         SSVAL(&variables[shared_size], 0, l1);
 181         SSVAL(&variables[shared_size], 2, l2);
 182
 183         pstrcpy(&variables[shared_size] + 4, name);
 184         pstrcpy(&variables[shared_size] + 4 + l1, val);
 185
 186         shared_size += l1+l2+4;
 187
 188         lseek(shared_fd, 0, SEEK_SET);
 189         if (write(shared_fd, variables, shared_size) != shared_size) {
 190                 DEBUG(0,("smbw_setshared failed (%s)\n", strerror(errno)));
 191                 exit(1);
 192         }
 193
 194         unlockit();
 195 }
 196
 197
 198 /*****************************************************************
 199 set an env variable - some systems don't have this
 200 *****************************************************************/
 201 int smbw_setenv(const char *name, const char *value)
 202 {
 203         pstring s;
 204         char *p;
 205         int ret = -1;
 206
 207         slprintf(s,sizeof(s)-1,"%s=%s", name, value);
 208
 209         p = strdup(s);
 210
 211         if (p) ret = putenv(p);
 212
 213         return ret;
 214 }
 215
 216 /*****************************************************************
 217 return true if the passed fd is the SMBW_HANDLE
 218 *****************************************************************/
 219 int smbw_shared_fd(int fd)
 220 {
 221         return (shared_fd && shared_fd == fd);
 222 }