BOOL sysv_cache_reload(void)
{
char **lines;
int i;
DEBUG(5, ("reloading sysv printcap cache\n"));
if ((lines = file_lines_pload("/usr/bin/lpstat -v", NULL)) == NULL)
return False;
for (i = 0; lines[i]; i++) {
char *name, *tmp;
char *buf = lines[i];
/* eat "system/device for " */
if (((tmp = strchr_m(buf, ' ')) == NULL) ||
((tmp = strchr_m(++tmp, ' ')) == NULL))
continue;
/*
* In case we're only at the "for ".
*/
if(!strncmp("for ", ++tmp, 4)) {
tmp=strchr_m(tmp, ' ');
tmp++;
}
/* Eat whitespace. */
while(*tmp == ' ')
++tmp;
/*
* On HPUX there is an extra line that can be ignored.
* d.thibadeau 2001/08/09
*/
if(!strncmp("remote to", tmp, 9))
continue;
name = tmp;
/* truncate the ": ..." */
if ((tmp = strchr_m(name, ':')) != NULL)
*tmp = '\0';
/* add it to the cache */
if (!pcap_cache_add(name, NULL)) {
file_lines_free(lines);
return False;
}
}
file_lines_free(lines);
return True;
}
static void populate_printers(void)
{
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_m(buf, ' ')) == NULL) ||
((tmp = strchr_m(++tmp, ' ')) == NULL))
continue;
/*
* In case we're only at the "for ".
*/
if(!strncmp("for ",++tmp,4)) {
tmp=strchr_m(tmp, ' ');
tmp++;
}
/* Eat whitespace. */
while(*tmp == ' ')
++tmp;
/*
* On HPUX there is an extra line that can be ignored.
* d.thibadeau 2001/08/09
*/
if(!strncmp("remote to",tmp,9))
continue;
name = tmp;
/* truncate the ": ..." */
if ((tmp = strchr_m(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"));
}
}
file_lines_free(lines);
}
/****************************************************************************
Read a SID from a file. This is for compatibility with the old MACHINE.SID
style of SID storage
****************************************************************************/
static BOOL read_sid_from_file(const char *fname, DOM_SID *sid)
{
char **lines;
int numlines;
BOOL ret;
lines = file_lines_load(fname, &numlines);
if (!lines || numlines < 1) {
if (lines) file_lines_free(lines);
return False;
}
ret = string_to_sid(sid, lines[0]);
file_lines_free(lines);
return ret;
}
static BOOL read_sid_from_file(char *fname, DOM_SID *sid)
{
char **lines;
int numlines;
BOOL ret;
lines = file_lines_load(fname, &numlines, False);
if (!lines || numlines < 1) {
if (lines)
file_lines_free(lines);
return False;
}
ret = string_to_sid(sid, lines[0]);
if (!ret)
DEBUG(0,("read_sid_from_file: Failed to convert machine SID. (%s)\n", lines[0]));
file_lines_free(lines);
return ret;
}
/****************************************************************************
get the current list of queued jobs
****************************************************************************/
static int generic_queue_get(const char *printer_name,
enum printing_types printing_type,
char *lpq_command,
print_queue_struct **q,
print_status_struct *status)
{
char **qlines;
int fd;
int numlines, i, qcount;
print_queue_struct *queue = NULL;
/* never do substitution when running the 'lpq command' since we can't
get it rigt when using the background update daemon. Make the caller
do it before passing off the command string to us here. */
print_run_command(-1, printer_name, False, lpq_command, &fd, NULL);
if (fd == -1) {
DEBUG(5,("generic_queue_get: Can't read print queue status for printer %s\n",
printer_name ));
return 0;
}
numlines = 0;
qlines = fd_lines_load(fd, &numlines);
close(fd);
/* turn the lpq output into a series of job structures */
qcount = 0;
ZERO_STRUCTP(status);
if (numlines)
queue = SMB_MALLOC_ARRAY(print_queue_struct, numlines+1);
if (queue) {
memset(queue, '\0', sizeof(print_queue_struct)*(numlines+1));
for (i=0; i<numlines; i++) {
/* parse the line */
if (parse_lpq_entry(printing_type,qlines[i],
&queue[qcount],status,qcount==0)) {
qcount++;
}
}
}
file_lines_free(qlines);
*q = queue;
return qcount;
}
/* load a msg file into the tdb */
static BOOL load_msg(const char *msg_file)
{
char **lines;
int num_lines, i;
char *msgid, *msgstr;
TDB_DATA key, data;
lines = file_lines_load(msg_file, &num_lines);
if (!lines) {
return False;
}
if (tdb_lockall(tdb) != 0) return False;
/* wipe the db */
tdb_traverse(tdb, tdb_traverse_delete_fn, NULL);
msgid = NULL;
for (i=0;i<num_lines;i++) {
if (strncmp(lines[i], "msgid \"", 7) == 0) {
msgid = lines[i] + 7;
}
if (msgid && strncmp(lines[i], "msgstr \"", 8) == 0) {
msgstr = lines[i] + 8;
trim_char(msgid, '\0', '\"');
trim_char(msgstr, '\0', '\"');
if (*msgstr == 0) {
msgstr = msgid;
}
all_string_sub(msgid, "\\n", "\n", 0);
all_string_sub(msgstr, "\\n", "\n", 0);
key.dptr = msgid;
key.dsize = strlen(msgid)+1;
data.dptr = msgstr;
data.dsize = strlen(msgstr)+1;
tdb_store(tdb, key, data, 0);
msgid = NULL;
}
}
file_lines_free(lines);
tdb_unlockall(tdb);
return True;
}
SMB_BIG_UINT sys_disk_free(connection_struct *conn, const char *path, bool small_query,
SMB_BIG_UINT *bsize,SMB_BIG_UINT *dfree,SMB_BIG_UINT *dsize)
{
SMB_BIG_UINT dfree_retval;
SMB_BIG_UINT dfree_q = 0;
SMB_BIG_UINT bsize_q = 0;
SMB_BIG_UINT dsize_q = 0;
const char *dfree_command;
(*dfree) = (*dsize) = 0;
(*bsize) = 512;
/*
* If external disk calculation specified, use it.
*/
dfree_command = lp_dfree_command(SNUM(conn));
if (dfree_command && *dfree_command) {
const char *p;
char **lines = NULL;
char *syscmd = NULL;
syscmd = talloc_asprintf(talloc_tos(),
"%s %s",
dfree_command,
path);
if (!syscmd) {
return (SMB_BIG_UINT)-1;
}
DEBUG (3, ("disk_free: Running command %s\n", syscmd));
lines = file_lines_pload(syscmd, NULL);
if (lines) {
char *line = lines[0];
DEBUG (3, ("Read input from dfree, \"%s\"\n", line));
*dsize = STR_TO_SMB_BIG_UINT(line, &p);
while (p && *p && isspace(*p))
p++;
if (p && *p)
*dfree = STR_TO_SMB_BIG_UINT(p, &p);
while (p && *p && isspace(*p))
p++;
if (p && *p)
*bsize = STR_TO_SMB_BIG_UINT(p, NULL);
else
*bsize = 1024;
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));
if (!*dsize)
*dsize = 2048;
if (!*dfree)
*dfree = 1024;
} else {
DEBUG (0, ("disk_free: sys_popen() failed for command %s. Error was : %s\n",
syscmd, strerror(errno) ));
if (sys_fsusage(path, dfree, dsize) != 0) {
DEBUG (0, ("disk_free: sys_fsusage() failed. Error was : %s\n",
strerror(errno) ));
return (SMB_BIG_UINT)-1;
}
}
} else {
if (sys_fsusage(path, dfree, dsize) != 0) {
DEBUG (0, ("disk_free: sys_fsusage() failed. Error was : %s\n",
strerror(errno) ));
return (SMB_BIG_UINT)-1;
}
}
if (disk_quotas(path, &bsize_q, &dfree_q, &dsize_q)) {
(*bsize) = bsize_q;
(*dfree) = MIN(*dfree,dfree_q);
(*dsize) = MIN(*dsize,dsize_q);
}
/* FIXME : Any reason for this assumption ? */
if (*bsize < 256) {
DEBUG(5,("disk_free:Warning: bsize == %d < 256 . Changing to assumed correct bsize = 512\n",(int)*bsize));
*bsize = 512;
}
if ((*dsize)<1) {
static bool done = false;
if (!done) {
DEBUG(0,("WARNING: dfree is broken on this system\n"));
done=true;
}
*dsize = 20*1024*1024/(*bsize);
*dfree = MAX(1,*dfree);
}
disk_norm(small_query,bsize,dfree,dsize);
if ((*bsize) < 1024) {
dfree_retval = (*dfree)/(1024/(*bsize));
} else {
dfree_retval = ((*bsize)/1024)*(*dfree);
}
return(dfree_retval);
}
static int command_set_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
{
const char *set_quota_command;
set_quota_command = lp_set_quota_command();
if (set_quota_command && *set_quota_command) {
char **lines;
pstring syscmd;
int _id = -1;
switch(qtype) {
case SMB_USER_QUOTA_TYPE:
case SMB_USER_FS_QUOTA_TYPE:
_id = id.uid;
break;
case SMB_GROUP_QUOTA_TYPE:
case SMB_GROUP_FS_QUOTA_TYPE:
_id = id.gid;
break;
default:
return -1;
}
#ifdef LARGE_SMB_OFF_T
slprintf(syscmd, sizeof(syscmd)-1,
"%s \"%s\" %d %d "
"%u %llu %llu "
"%llu %llu %llu ",
set_quota_command, path, qtype, _id, dp->qflags,
(long long unsigned)dp->softlimit,(long long unsigned)dp->hardlimit,
(long long unsigned)dp->isoftlimit,(long long unsigned)dp->ihardlimit,
(long long unsigned)dp->bsize);
#else /* LARGE_SMB_OFF_T */
slprintf(syscmd, sizeof(syscmd)-1,
"%s \"%s\" %d %d "
"%u %lu %lu "
"%lu %lu %lu ",
set_quota_command, path, qtype, _id, dp->qflags,
(long unsigned)dp->softlimit,(long unsigned)dp->hardlimit,
(long unsigned)dp->isoftlimit,(long unsigned)dp->ihardlimit,
(long unsigned)dp->bsize);
#endif /* LARGE_SMB_OFF_T */
DEBUG (3, ("get_quota: Running command %s\n", syscmd));
lines = file_lines_pload(syscmd, NULL);
if (lines) {
char *line = lines[0];
DEBUG (3, ("Read output from set_quota, \"%s\"\n", line));
file_lines_free(lines);
return 0;
}
DEBUG (0, ("set_quota_command failed!\n"));
return -1;
}
errno = ENOSYS;
return -1;
}
static int command_get_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
{
const char *get_quota_command;
get_quota_command = lp_get_quota_command();
if (get_quota_command && *get_quota_command) {
const char *p;
char *p2;
char **lines;
pstring syscmd;
int _id = -1;
switch(qtype) {
case SMB_USER_QUOTA_TYPE:
case SMB_USER_FS_QUOTA_TYPE:
_id = id.uid;
break;
case SMB_GROUP_QUOTA_TYPE:
case SMB_GROUP_FS_QUOTA_TYPE:
_id = id.gid;
break;
default:
DEBUG(0,("invalid quota type.\n"));
return -1;
}
slprintf(syscmd, sizeof(syscmd)-1,
"%s \"%s\" %d %d",
get_quota_command, path, qtype, _id);
DEBUG (3, ("get_quota: Running command %s\n", syscmd));
lines = file_lines_pload(syscmd, NULL);
if (lines) {
char *line = lines[0];
DEBUG (3, ("Read output from get_quota, \"%s\"\n", line));
/* we need to deal with long long unsigned here, if supported */
dp->qflags = (enum SMB_QUOTA_TYPE)strtoul(line, &p2, 10);
p = p2;
while (p && *p && isspace(*p))
p++;
if (p && *p)
dp->curblocks = STR_TO_SMB_BIG_UINT(p, &p);
else
goto invalid_param;
while (p && *p && isspace(*p))
p++;
if (p && *p)
dp->softlimit = STR_TO_SMB_BIG_UINT(p, &p);
else
goto invalid_param;
while (p && *p && isspace(*p))
p++;
if (p && *p)
dp->hardlimit = STR_TO_SMB_BIG_UINT(p, &p);
else
goto invalid_param;
while (p && *p && isspace(*p))
p++;
if (p && *p)
dp->curinodes = STR_TO_SMB_BIG_UINT(p, &p);
else
goto invalid_param;
while (p && *p && isspace(*p))
p++;
if (p && *p)
dp->isoftlimit = STR_TO_SMB_BIG_UINT(p, &p);
else
goto invalid_param;
while (p && *p && isspace(*p))
p++;
if (p && *p)
dp->ihardlimit = STR_TO_SMB_BIG_UINT(p, &p);
else
goto invalid_param;
while (p && *p && isspace(*p))
p++;
if (p && *p)
dp->bsize = STR_TO_SMB_BIG_UINT(p, NULL);
else
dp->bsize = 1024;
file_lines_free(lines);
DEBUG (3, ("Parsed output of get_quota, ...\n"));
#ifdef LARGE_SMB_OFF_T
DEBUGADD (5,(
"qflags:%u curblocks:%llu softlimit:%llu hardlimit:%llu\n"
"curinodes:%llu isoftlimit:%llu ihardlimit:%llu bsize:%llu\n",
dp->qflags,(long long unsigned)dp->curblocks,
(long long unsigned)dp->softlimit,(long long unsigned)dp->hardlimit,
(long long unsigned)dp->curinodes,
(long long unsigned)dp->isoftlimit,(long long unsigned)dp->ihardlimit,
(long long unsigned)dp->bsize));
#else /* LARGE_SMB_OFF_T */
DEBUGADD (5,(
"qflags:%u curblocks:%lu softlimit:%lu hardlimit:%lu\n"
"curinodes:%lu isoftlimit:%lu ihardlimit:%lu bsize:%lu\n",
dp->qflags,(long unsigned)dp->curblocks,
(long unsigned)dp->softlimit,(long unsigned)dp->hardlimit,
(long unsigned)dp->curinodes,
(long unsigned)dp->isoftlimit,(long unsigned)dp->ihardlimit,
(long unsigned)dp->bsize));
#endif /* LARGE_SMB_OFF_T */
return 0;
}
DEBUG (0, ("get_quota_command failed!\n"));
return -1;
}
errno = ENOSYS;
return -1;
invalid_param:
DEBUG(0,("The output of get_quota_command is invalid!\n"));
return -1;
}
