smb_ucs2_t *wsys_getwd(smb_ucs2_t *s);
int wsys_chown(const smb_ucs2_t *wfname, uid_t uid, gid_t gid);
int wsys_chroot(const smb_ucs2_t *wfname);
-FILE *sys_popen(const char *command, const char *mode, BOOL paranoid);
-int sys_pclose( FILE *fp);
+int sys_popen(const char *command);
+int sys_pclose(int fd);
/*The following definitions come from lib/talloc.c */
BOOL setfilepwpos(void *vp, SMB_BIG_UINT tok);
int getfileline(void *vp, char *linebuf, int linebuf_size);
char *fgets_slash(char *s2,int maxlen,FILE *f);
+char *file_pload(char *syscmd, size_t *size);
+char *file_load(char *fname, size_t *size);
char **file_lines_load(char *fname, int *numlines);
+char **file_lines_pload(char *syscmd, int *numlines);
void file_lines_free(char **lines);
/*The following definitions come from lib/util_sec.c */
/**************************************************************************
Wrapper for popen. Safer as it doesn't search a path.
Modified from the glibc sources.
+ modified by tridge to return a file descriptor. We must kick our FILE* habit
****************************************************************************/
-
typedef struct _popen_list
{
- FILE *fp;
+ int fd;
pid_t child_pid;
struct _popen_list *next;
} popen_list;
static popen_list *popen_chain;
-FILE *sys_popen(const char *command, const char *mode, BOOL paranoid)
+int sys_popen(const char *command)
{
int parent_end, child_end;
int pipe_fds[2];
- popen_list *entry = NULL;
+ popen_list *entry = NULL;
char **argl = NULL;
if (pipe(pipe_fds) < 0)
- return NULL;
+ return -1;
- if (mode[0] == 'r' && mode[1] == '\0') {
- parent_end = pipe_fds[0];
- child_end = pipe_fds[1];
- } else if (mode[0] == 'w' && mode[1] == '\0') {
- parent_end = pipe_fds[1];
- child_end = pipe_fds[0];
- } else {
- errno = EINVAL;
- goto err_exit;
- }
+ parent_end = pipe_fds[0];
+ child_end = pipe_fds[1];
if (!*command) {
errno = EINVAL;
if(!(argl = extract_args(command)))
goto err_exit;
- if(paranoid) {
- /*
- * Do some basic paranioa checks. Do a stat on the parent
- * directory and ensure it's not world writable. Do a stat
- * on the file itself and ensure it's owned by root and not
- * world writable. Note this does *not* prevent symlink races,
- * but is a generic "don't let the admin screw themselves"
- * check.
- */
-
- SMB_STRUCT_STAT st;
- pstring dir_name;
- char *ptr = strrchr(argl[0], '/');
-
- if(sys_stat(argl[0], &st) != 0)
- goto err_exit;
-
- if((st.st_uid != (uid_t)0) || (st.st_mode & S_IWOTH)) {
- errno = EACCES;
- goto err_exit;
- }
-
- if(!ptr) {
- /*
- * No '/' in name - use current directory.
- */
- pstrcpy(dir_name, ".");
- } else {
-
- /*
- * Copy into a pstring and do the checks
- * again (in case we were length tuncated).
- */
-
- pstrcpy(dir_name, argl[0]);
- ptr = strrchr(dir_name, '/');
- if(!ptr) {
- errno = EINVAL;
- goto err_exit;
- }
- if(strcmp(dir_name, "/") != 0)
- *ptr = '\0';
- if(!dir_name[0])
- pstrcpy(dir_name, ".");
- }
-
- if(sys_stat(argl[0], &st) != 0)
- goto err_exit;
-
- if(!S_ISDIR(st.st_mode) || (st.st_mode & S_IWOTH)) {
- errno = EACCES;
- goto err_exit;
- }
- }
-
entry->child_pid = fork();
if (entry->child_pid == -1) {
-
- /*
- * Error !
- */
-
goto err_exit;
}
* Child !
*/
- int child_std_end = (mode[0] == 'r') ? STDOUT_FILENO : STDIN_FILENO;
+ int child_std_end = STDOUT_FILENO;
popen_list *p;
close(parent_end);
*/
for (p = popen_chain; p; p = p->next)
- close(fileno(p->fp));
+ close(p->fd);
execv(argl[0], argl);
_exit (127);
close (child_end);
free((char *)argl);
- /*
- * Create the FILE * representing this fd.
- */
- entry->fp = fdopen(parent_end, mode);
-
/* Link into popen_chain. */
entry->next = popen_chain;
popen_chain = entry;
- return entry->fp;
+ return entry->fd;
err_exit:
free((char *)argl);
close(pipe_fds[0]);
close(pipe_fds[1]);
- return NULL;
+ return -1;
}
/**************************************************************************
Wrapper for pclose. Modified from the glibc sources.
****************************************************************************/
-
-int sys_pclose( FILE *fp)
+int sys_pclose(int fd)
{
int wstatus;
popen_list **ptr = &popen_chain;
/* Unlink from popen_chain. */
for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
- if ((*ptr)->fp == fp) {
+ if ((*ptr)->fd == fd) {
entry = *ptr;
*ptr = (*ptr)->next;
status = 0;
}
}
- if (status < 0 || close(fileno(entry->fp)) < 0)
+ if (status < 0 || close(entry->fd) < 0)
return -1;
/*
/****************************************************************************
-load a file into memory and return an array of pointers to lines in the file
-must be freed with file_lines_free()
+load from a pipe into memory
****************************************************************************/
-char **file_lines_load(char *fname, int *numlines)
+char *file_pload(char *syscmd, size_t *size)
{
- int fd, i;
+ int fd, n;
+ char *p;
+ pstring buf;
+ size_t total;
+
+ fd = sys_popen(syscmd);
+ if (fd == -1) return NULL;
+
+ p = NULL;
+ total = 0;
+
+ while ((n = read(fd, buf, sizeof(buf))) > 0) {
+ p = Realloc(p, total + n + 1);
+ if (!p) {
+ close(fd);
+ return NULL;
+ }
+ memcpy(p+total, buf, n);
+ total += n;
+ }
+ p[total] = 0;
+
+ sys_pclose(fd);
+
+ if (size) *size = total;
+
+ return p;
+}
+
+
+/****************************************************************************
+load a file into memory
+****************************************************************************/
+char *file_load(char *fname, size_t *size)
+{
+ int fd;
SMB_STRUCT_STAT sbuf;
- char *p, *s, **ret;
- size_t size;
+ char *p;
fd = open(fname,O_RDONLY);
if (fd == -1) return NULL;
if (sys_fstat(fd, &sbuf) != 0) return NULL;
- size = sbuf.st_size;
- if (size == 0) return NULL;
+ if (sbuf.st_size == 0) return NULL;
- p = (char *)malloc(size+1);
+ p = (char *)malloc(sbuf.st_size+1);
if (!p) return NULL;
- if (read(fd, p, size) != size) {
+ if (read(fd, p, sbuf.st_size) != sbuf.st_size) {
free(p);
return NULL;
}
- p[size] = 0;
+ p[sbuf.st_size] = 0;
close(fd);
+ if (size) *size = sbuf.st_size;
+
+ return p;
+}
+
+
+/****************************************************************************
+parse a buffer into lines
+****************************************************************************/
+static char **file_lines_parse(char *p, size_t size, int *numlines)
+{
+ int i;
+ char *s, **ret;
+
+ if (!p) return NULL;
+
for (s = p, i=0; s < p+size; s++) {
if (s[0] == '\n') i++;
}
return ret;
}
+
+/****************************************************************************
+load a file into memory and return an array of pointers to lines in the file
+must be freed with file_lines_free()
+****************************************************************************/
+char **file_lines_load(char *fname, int *numlines)
+{
+ char *p;
+ size_t size;
+
+ p = file_load(fname, &size);
+ if (!p) return NULL;
+
+ return file_lines_parse(p, size, numlines);
+}
+
+
+/****************************************************************************
+load a pipe into memory and return an array of pointers to lines in the data
+must be freed with file_lines_free()
+****************************************************************************/
+char **file_lines_pload(char *syscmd, int *numlines)
+{
+ char *p;
+ size_t size;
+
+ p = file_pload(syscmd, &size);
+ if (!p) return NULL;
+
+ return file_lines_parse(p, size, numlines);
+}
+
/****************************************************************************
free lines loaded with file_lines_load
****************************************************************************/
Do the work of sourcing in environment variable/value pairs.
***************************************************************************/
-static BOOL source_env(FILE *fenv)
+static BOOL source_env(char **lines)
{
- pstring line;
char *varval;
size_t len;
+ int i;
char *p;
- while (!feof(fenv)) {
- if (fgets(line, sizeof(line), fenv) == NULL)
- break;
-
- if(feof(fenv))
- break;
+ for (i=0; lines[i]; i++) {
+ char *line = lines[i];
if((len = strlen(line)) == 0)
continue;
{
pstring fname;
char *p = fname;
- FILE *env;
BOOL result;
+ char **lines;
pstrcpy(fname,pszParmValue);
*/
if (*p == '|') {
-
- DEBUG(4, ("handle_source_env: source env from pipe\n"));
- p++;
-
- if ((env = sys_popen(p, "r", True)) == NULL) {
- DEBUG(0,("handle_source_env: Failed to popen %s. Error was %s\n", p, strerror(errno) ));
- return(False);
- }
-
- DEBUG(4, ("handle_source_env: calling source_env()\n"));
- result = source_env(env);
- sys_pclose(env);
-
+ lines = file_lines_pload(p+1, NULL);
} else {
+ lines = file_lines_load(fname, NULL);
+ }
- SMB_STRUCT_STAT st;
-
- DEBUG(4, ("handle_source_env: source env from file %s\n", fname));
- if ((env = sys_fopen(fname, "r")) == NULL) {
- DEBUG(0,("handle_source_env: Failed to open file %s, Error was %s\n", fname, strerror(errno) ));
- return(False);
- }
-
- /*
- * Ensure this file is owned by root and not writable by world.
- */
- if(sys_fstat(fileno(env), &st) != 0) {
- DEBUG(0,("handle_source_env: Failed to stat file %s, Error was %s\n", fname, strerror(errno) ));
- fclose(env);
- return False;
- }
+ if (!lines) {
+ DEBUG(0,("handle_source_env: Failed to open file %s, Error was %s\n", fname, strerror(errno) ));
+ return(False);
+ }
- if((st.st_uid != (uid_t)0) || (st.st_mode & S_IWOTH)) {
- DEBUG(0,("handle_source_env: unsafe to source env file %s. Not owned by root or world writable\n", fname ));
- fclose(env);
- return False;
- }
+ result=source_env(lines);
+ file_lines_free(lines);
- result=source_env(env);
- fclose(env);
- }
return(result);
}
static char *bufr = NULL;
static int bSize = 0;
+/* we can't use FILE* due to the 256 fd limit - use this cheap hack
+ instead */
+typedef struct {
+ char *buf;
+ char *p;
+ size_t size;
+} myFILE;
+
+static int mygetc(myFILE *f)
+{
+ if (f->p >= f->buf+f->size) return EOF;
+ return (int)*(f->p++);
+}
+
+static void myfile_close(myFILE *f)
+{
+ if (!f) return;
+ if (f->buf) free(f->buf);
+ free(f);
+}
+
/* -------------------------------------------------------------------------- **
* Functions...
*/
-static int EatWhitespace( FILE *InFile )
+static int EatWhitespace( myFILE *InFile )
/* ------------------------------------------------------------------------ **
* Scan past whitespace (see ctype(3C)) and return the first non-whitespace
* character, or newline, or EOF.
{
int c;
- for( c = getc( InFile ); isspace( c ) && ('\n' != c); c = getc( InFile ) )
+ for( c = mygetc( InFile ); isspace( c ) && ('\n' != c); c = mygetc( InFile ) )
;
return( c );
} /* EatWhitespace */
-static int EatComment( FILE *InFile )
+static int EatComment( myFILE *InFile )
/* ------------------------------------------------------------------------ **
* Scan to the end of a comment.
*
{
int c;
- for( c = getc( InFile ); ('\n'!=c) && (EOF!=c) && (c>0); c = getc( InFile ) )
+ for( c = mygetc( InFile ); ('\n'!=c) && (EOF!=c) && (c>0); c = mygetc( InFile ) )
;
return( c );
} /* EatComment */
}
-static BOOL Section( FILE *InFile, BOOL (*sfunc)(char *) )
+static BOOL Section( myFILE *InFile, BOOL (*sfunc)(char *) )
/* ------------------------------------------------------------------------ **
* Scan a section name, and pass the name to function sfunc().
*
return( False );
}
end = ( (i > 0) && (' ' == bufr[i - 1]) ) ? (i - 1) : (i);
- c = getc( InFile ); /* Continue with next line. */
+ c = mygetc( InFile ); /* Continue with next line. */
break;
default: /* All else are a valid name chars. */
{
bufr[i++] = c;
end = i;
- c = getc( InFile );
+ c = mygetc( InFile );
}
}
}
return( False );
} /* Section */
-static BOOL Parameter( FILE *InFile, BOOL (*pfunc)(char *, char *), int c )
+static BOOL Parameter( myFILE *InFile, BOOL (*pfunc)(char *, char *), int c )
/* ------------------------------------------------------------------------ **
* Scan a parameter name and value, and pass these two fields to pfunc().
*
return( True );
}
end = ( (i > 0) && (' ' == bufr[i - 1]) ) ? (i - 1) : (i);
- c = getc( InFile ); /* Read past eoln. */
+ c = mygetc( InFile ); /* Read past eoln. */
break;
case '\0': /* Shouldn't have EOF within param name. */
{
bufr[i++] = c;
end = i;
- c = getc( InFile );
+ c = mygetc( InFile );
}
}
}
switch( c )
{
case '\r': /* Explicitly remove '\r' because the older */
- c = getc( InFile ); /* version called fgets_slash() which also */
+ c = mygetc( InFile ); /* version called fgets_slash() which also */
break; /* removes them. */
case '\n': /* Marks end of value unless there's a '\'. */
{
for( end = i; (end >= 0) && isspace(bufr[end]); end-- )
;
- c = getc( InFile );
+ c = mygetc( InFile );
}
break;
bufr[i++] = c; /* not advance <end>. This allows trimming */
if( !isspace( c ) ) /* of whitespace at the end of the line. */
end = i;
- c = getc( InFile );
+ c = mygetc( InFile );
break;
}
}
return( pfunc( bufr, &bufr[vstart] ) ); /* Pass name & value to pfunc(). */
} /* Parameter */
-static BOOL Parse( FILE *InFile,
+static BOOL Parse( myFILE *InFile,
BOOL (*sfunc)(char *),
BOOL (*pfunc)(char *, char *) )
/* ------------------------------------------------------------------------ **
return( True );
} /* Parse */
-static FILE *OpenConfFile( char *FileName )
+static myFILE *OpenConfFile( char *FileName )
/* ------------------------------------------------------------------------ **
* Open a configuration file.
*
* Input: FileName - The pathname of the config file to be opened.
*
- * Output: A pointer of type (FILE *) to the opened file, or NULL if the
- * file could not be opened.
+ * Output: A pointer of type (char **) to the lines of the file
*
* ------------------------------------------------------------------------ **
*/
{
- FILE *OpenedFile;
char *func = "params.c:OpenConfFile() -";
extern BOOL in_client;
int lvl = in_client?1:0;
+ myFILE *ret;
- if( NULL == FileName || 0 == *FileName )
- {
- DEBUG( lvl, ("%s No configuration filename specified.\n", func) );
- return( NULL );
- }
+ ret = (myFILE *)malloc(sizeof(*ret));
+ if (!ret) return NULL;
- OpenedFile = sys_fopen( FileName, "r" );
- if( NULL == OpenedFile )
+ ret->buf = file_load(FileName, &ret->size);
+ if( NULL == ret->buf )
{
DEBUG( lvl,
("%s Unable to open configuration file \"%s\":\n\t%s\n",
func, FileName, strerror(errno)) );
+ free(ret);
+ ret = NULL;
}
- return( OpenedFile );
+ ret->p = ret->buf;
+ return( ret );
} /* OpenConfFile */
BOOL pm_process( char *FileName,
*/
{
int result;
- FILE *InFile;
+ myFILE *InFile;
char *func = "params.c:pm_process() -";
InFile = OpenConfFile( FileName ); /* Open the config file. */
if( NULL == bufr )
{
DEBUG(0,("%s memory allocation failure.\n", func));
- fclose(InFile);
+ myfile_close(InFile);
return( False );
}
result = Parse( InFile, sfunc, pfunc );
bSize = 0;
}
- fclose(InFile);
+ myfile_close(InFile);
if( !result ) /* Generic failure. */
{
static void populate_printers(void)
{
- FILE *fp;
-
- if ((fp = sys_popen("/usr/bin/lpstat -v", "r", False)) != NULL) {
- char buf[BUFSIZ];
-
- while (fgets(buf, sizeof (buf), fp) != NULL) {
- printer_t *ptmp;
- char *name, *tmp;
-
- /* eat "system/device for " */
- if (((tmp = strchr(buf, ' ')) == NULL) ||
- ((tmp = strchr(++tmp, ' ')) == NULL))
- continue;
-
- /*
- * In case we're only at the "for ".
- */
-
- if(!strncmp("for ",++tmp,4))
- {
- tmp=strchr(tmp, ' ');
- tmp++;
- }
- name = tmp;
-
- /* truncate the ": ..." */
- if ((tmp = strchr(name, ':')) != NULL)
- *tmp = '\0';
-
- /* add it to the cache */
- if ((ptmp = malloc(sizeof (*ptmp))) != NULL) {
- ZERO_STRUCTP(ptmp);
- if((ptmp->name = strdup(name)) == NULL)
- DEBUG(0,("populate_printers: malloc fail in strdup !\n"));
- ptmp->next = printers;
- printers = ptmp;
- } else {
- DEBUG(0,("populate_printers: malloc fail for ptmp\n"));
- }
+ char **lines;
+ int i;
+
+ lines = file_lines_pload("/usr/bin/lpstat -v", NULL);
+ if (!lines) return;
+
+ for (i=0;lines[i];i++) {
+ printer_t *ptmp;
+ char *name, *tmp;
+ char *buf = lines[i];
+
+ /* eat "system/device for " */
+ if (((tmp = strchr(buf, ' ')) == NULL) ||
+ ((tmp = strchr(++tmp, ' ')) == NULL))
+ continue;
+
+ /*
+ * In case we're only at the "for ".
+ */
+
+ if(!strncmp("for ",++tmp,4)) {
+ tmp=strchr(tmp, ' ');
+ tmp++;
+ }
+ name = tmp;
+
+ /* truncate the ": ..." */
+ if ((tmp = strchr(name, ':')) != NULL)
+ *tmp = '\0';
+
+ /* add it to the cache */
+ if ((ptmp = malloc(sizeof (*ptmp))) != NULL) {
+ ZERO_STRUCTP(ptmp);
+ if((ptmp->name = strdup(name)) == NULL)
+ DEBUG(0,("populate_printers: malloc fail in strdup !\n"));
+ ptmp->next = printers;
+ printers = ptmp;
+ } else {
+ DEBUG(0,("populate_printers: malloc fail for ptmp\n"));
}
- sys_pclose(fp);
- } else {
- DEBUG(0,( "Unable to run lpstat!\n"));
}
+
+ file_lines_free(lines);
}
(*dfree) = (*dsize) = 0;
(*bsize) = 512;
-
/*
* If external disk calculation specified, use it.
*/
dfree_command = lp_dfree_command();
if (dfree_command && *dfree_command) {
- pstring line;
char *p;
- FILE *pp;
+ char **lines;
+ pstring syscmd;
- slprintf (line, sizeof(pstring) - 1, "%s %s", dfree_command, path);
- DEBUG (3, ("disk_free: Running command %s\n", line));
+ slprintf(syscmd, sizeof(syscmd), "%s %s", dfree_command, path);
+ DEBUG (3, ("disk_free: Running command %s\n", syscmd));
- pp = sys_popen(line, "r", False);
- if (pp) {
- fgets(line, sizeof(pstring), pp);
- line[sizeof(pstring)-1] = '\0';
+ lines = file_lines_pload(syscmd, NULL);
+ if (lines) {
+ char *line = lines[0];
if (strlen(line) > 0)
line[strlen(line)-1] = '\0';
*bsize = (SMB_BIG_UINT)strtoul(p, NULL, 10);
else
*bsize = 1024;
- sys_pclose (pp);
+ file_lines_free(lines);
DEBUG (3, ("Parsed output of dfree, dsize=%u, dfree=%u, bsize=%u\n",
(unsigned int)*dsize, (unsigned int)*dfree, (unsigned int)*bsize));
*dfree = 1024;
} else {
DEBUG (0, ("disk_free: sys_popen() failed for command %s. Error was : %s\n",
- line, strerror(errno) ));
+ syscmd, strerror(errno) ));
fsusage(path, dfree, dsize);
}
} else
{
int i,ok=0;
pstring tok,driver,datafile,langmon,helpfile,datatype;
- char *p,*q;
- FILE *f;
- pstring fname;
+ char *p;
+ char **lines, *line;
- pstrcpy(fname,lp_driverfile());
- f=sys_fopen(fname,"r");
- if (!f) {
- DEBUG(3,("fill_printq_info: Can't open %s - %s\n",fname,strerror(errno)));
+ lines = file_lines_load(lp_driverfile(),NULL);
+ if (!lines) {
+ DEBUG(3,("fill_printq_info: Can't open %s - %s\n",
+ lp_driverfile(),strerror(errno)));
desc->errcode=NERR_notsupported;
return;
}
- if((p=(char *)malloc(8192*sizeof(char))) == NULL) {
- DEBUG(0,("fill_printq_info: malloc fail !\n"));
- desc->errcode=NERR_notsupported;
- fclose(f);
- return;
- }
-
- memset(p, '\0',8192*sizeof(char));
- q=p;
-
/* lookup the long printer driver name in the file
description */
- while (f && !feof(f) && !ok) {
- p = q; /* reset string pointer */
- fgets(p,8191,f);
- p[strlen(p)-1]='\0';
+ for (i=0;lines[i] && !ok;i++) {
+ p = lines[i];
if (next_token(&p,tok,":",sizeof(tok)) &&
(strlen(lp_printerdriver(snum)) == strlen(tok)) &&
(!strncmp(tok,lp_printerdriver(snum),strlen(lp_printerdriver(snum)))))
ok=1;
}
- fclose(f);
+ line = strdup(p);
+ p = line;
+ file_lines_free(lines);
/* driver file name */
if (ok && !next_token(&p,driver,":",sizeof(driver))) ok = 0;
DEBUG(3,("fill_printq_info: Can't supply driver files\n"));
desc->errcode=NERR_notsupported;
}
- free(q);
+ free(line);
}
/* This function returns the number of files for a given driver */
static int get_printerdrivernumber(int snum)
{
- int i=0,ok=0;
- pstring tok;
- char *p,*q;
- FILE *f;
- pstring fname;
-
- pstrcpy(fname,lp_driverfile());
-
- DEBUG(4,("In get_printerdrivernumber: %s\n",fname));
- f=sys_fopen(fname,"r");
- if (!f) {
- DEBUG(3,("get_printerdrivernumber: Can't open %s - %s\n",fname,strerror(errno)));
- return(0);
- }
-
- if((p=(char *)malloc(8192*sizeof(char))) == NULL) {
- DEBUG(3,("get_printerdrivernumber: malloc fail !\n"));
- fclose(f);
- return 0;
- }
-
- q=p; /* need it to free memory because p change ! */
-
- /* lookup the long printer driver name in the file description */
- while (!feof(f) && !ok)
- {
- p = q; /* reset string pointer */
- fgets(p,8191,f);
- if (next_token(&p,tok,":",sizeof(tok)) &&
- (!strncmp(tok,lp_printerdriver(snum),strlen(lp_printerdriver(snum)))))
- ok=1;
- }
- fclose(f);
-
- if (ok) {
- /* skip 5 fields */
- i = 5;
- while (*p && i) {
- if (*p++ == ':') i--;
- }
- if (!*p || i)
- return(0);
+ int i=0,ok=0;
+ pstring tok;
+ char *p;
+ char **lines, *line;
- /* count the number of files */
- while (next_token(&p,tok,",",sizeof(tok)))
- i++;
- }
- free(q);
-
- return(i);
+ lines = file_lines_load(lp_driverfile(), NULL);
+ if (!lines) {
+ DEBUG(3,("get_printerdrivernumber: Can't open %s - %s\n",
+ lp_driverfile(),strerror(errno)));
+ return(0);
+ }
+
+ /* lookup the long printer driver name in the file description */
+ for (i=0;lines[i] && !ok; i++) {
+ p = lines[i];
+ if (next_token(&p,tok,":",sizeof(tok)) &&
+ (!strncmp(tok,lp_printerdriver(snum),strlen(lp_printerdriver(snum)))))
+ ok=1;
+ }
+ line = strdup(p);
+ p = line;
+ file_lines_free(lines);
+
+ if (ok) {
+ /* skip 5 fields */
+ i = 5;
+ while (*p && i) {
+ if (*p++ == ':') i--;
+ }
+ if (!*p || i)
+ return(0);
+
+ /* count the number of files */
+ while (next_token(&p,tok,",",sizeof(tok)))
+ i++;
+ }
+ free(line);
+
+ return(i);
}
static BOOL api_DosPrintQGetInfo(connection_struct *conn,
struct srv_info_struct **servers,
char *domain)
{
- FILE *f;
- pstring fname;
int count=0;
int alloced=0;
- pstring line;
+ char **lines;
BOOL local_list_only;
+ int i;
- pstrcpy(fname,lp_lockdir());
- trim_string(fname,NULL,"/");
- pstrcat(fname,"/");
- pstrcat(fname,SERVER_LIST);
-
- f = sys_fopen(fname,"r");
-
- if (!f) {
- DEBUG(4,("Can't open %s - %s\n",fname,strerror(errno)));
+ lines = file_lines_load(lock_path(SERVER_LIST), NULL);
+ if (!lines) {
+ DEBUG(4,("Can't open %s - %s\n",lock_path(SERVER_LIST),strerror(errno)));
return(0);
}
DEBUG(4,("Servertype search: %8x\n",servertype));
- while (!feof(f))
- {
+ for (i=0;lines[i];i++) {
fstring stype;
struct srv_info_struct *s;
- char *ptr = line;
+ char *ptr = lines[i];
BOOL ok = True;
- *ptr = 0;
- fgets(line,sizeof(line)-1,f);
- if (!*line) continue;
+ if (!*ptr) continue;
if (count == alloced) {
alloced += 10;
}
}
- fclose(f);
+ file_lines_free(lines);
return(count);
}
git.samba.org / obnox / samba-ctdb.git / commitdiff