cups_file_t * /* O - CUPS file or @code NULL@ on error */
cupsTempFile2(char *filename, /* I - Pointer to buffer */
int len) /* I - Size of buffer */
{
cups_file_t *file; /* CUPS file */
int fd; /* File descriptor */
if ((fd = cupsTempFd(filename, len)) < 0)
return (NULL);
else if ((file = cupsFileOpenFd(fd, "w")) == NULL)
{
close(fd);
unlink(filename);
return (NULL);
}
else
return (file);
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
int status; /* Exit status */
char filename[1024]; /* Filename buffer */
cups_file_t *fp; /* File pointer */
#ifndef WIN32
int fds[2]; /* Open file descriptors */
cups_file_t *fdfile; /* File opened with cupsFileOpenFd() */
#endif /* !WIN32 */
int count; /* Number of lines in file */
if (argc == 1)
{
/*
* Do uncompressed file tests...
*/
status = read_write_tests(0);
#ifdef HAVE_LIBZ
/*
* Do compressed file tests...
*/
putchar('\n');
status += read_write_tests(1);
#endif /* HAVE_LIBZ */
/*
* Do uncompressed random I/O tests...
*/
status += random_tests();
#ifndef WIN32
/*
* Test fdopen and close without reading...
*/
pipe(fds);
close(fds[1]);
fputs("\ncupsFileOpenFd(fd, \"r\"): ", stdout);
fflush(stdout);
if ((fdfile = cupsFileOpenFd(fds[0], "r")) == NULL)
{
puts("FAIL");
status ++;
}
else
{
/*
* Able to open file, now close without reading. If we don't return
* before the alarm fires, that is a failure and we will crash on the
* alarm signal...
*/
puts("PASS");
fputs("cupsFileClose(no read): ", stdout);
fflush(stdout);
alarm(5);
cupsFileClose(fdfile);
alarm(0);
puts("PASS");
}
#endif /* !WIN32 */
/*
* Count lines in psglyphs, rewind, then count again.
*/
fputs("\ncupsFileOpen(\"../data/media.defs\", \"r\"): ", stdout);
if ((fp = cupsFileOpen("../data/media.defs", "r")) == NULL)
{
puts("FAIL");
status ++;
}
else
{
puts("PASS");
fputs("cupsFileGets: ", stdout);
if ((count = count_lines(fp)) != 208)
{
printf("FAIL (got %d lines, expected 208)\n", count);
status ++;
}
else
{
puts("PASS");
fputs("cupsFileRewind: ", stdout);
if (cupsFileRewind(fp) != 0)
{
puts("FAIL");
status ++;
}
else
{
puts("PASS");
fputs("cupsFileGets: ", stdout);
if ((count = count_lines(fp)) != 208)
{
printf("FAIL (got %d lines, expected 208)\n", count);
status ++;
}
else
puts("PASS");
}
}
cupsFileClose(fp);
}
/*
* Test path functions...
*/
fputs("\ncupsFileFind: ", stdout);
#ifdef WIN32
if (cupsFileFind("notepad.exe", "C:/WINDOWS", 1, filename, sizeof(filename)) &&
cupsFileFind("notepad.exe", "C:/WINDOWS;C:/WINDOWS/SYSTEM32", 1, filename, sizeof(filename)))
#else
if (cupsFileFind("cat", "/bin", 1, filename, sizeof(filename)) &&
cupsFileFind("cat", "/bin:/usr/bin", 1, filename, sizeof(filename)))
#endif /* WIN32 */
printf("PASS (%s)\n", filename);
else
{
puts("FAIL");
status ++;
}
/*
* Summarize the results and return...
*/
if (!status)
puts("\nALL TESTS PASSED!");
else
printf("\n%d TEST(S) FAILED!\n", status);
}
else
{
/*
* Cat the filename on the command-line...
*/
char line[1024]; /* Line from file */
if ((fp = cupsFileOpen(argv[1], "r")) == NULL)
{
perror(argv[1]);
status = 1;
}
else
{
status = 0;
while (cupsFileGets(fp, line, sizeof(line)))
puts(line);
if (!cupsFileEOF(fp))
perror(argv[1]);
cupsFileClose(fp);
}
}
return (status);
}
cups_file_t * /* O - CUPS file or NULL on error */
cupsdPipeCommand(int *pid, /* O - Process ID or 0 on error */
const char *command, /* I - Command to run */
char **argv, /* I - Arguments to pass to command */
int user) /* I - User to run as or 0 for current */
{
int fd, /* Temporary file descriptor */
fds[2]; /* Pipe file descriptors */
/*
* First create the pipe...
*/
if (pipe(fds))
{
*pid = 0;
return (NULL);
}
/*
* Set the "close on exec" flag on each end of the pipe...
*/
if (fcntl(fds[0], F_SETFD, fcntl(fds[0], F_GETFD) | FD_CLOEXEC))
{
close(fds[0]);
close(fds[1]);
*pid = 0;
return (NULL);
}
if (fcntl(fds[1], F_SETFD, fcntl(fds[1], F_GETFD) | FD_CLOEXEC))
{
close(fds[0]);
close(fds[1]);
*pid = 0;
return (NULL);
}
/*
* Then run the command...
*/
if ((*pid = fork()) < 0)
{
/*
* Unable to fork!
*/
*pid = 0;
close(fds[0]);
close(fds[1]);
return (NULL);
}
else if (!*pid)
{
/*
* Child comes here...
*/
if (!getuid() && user)
setuid(user); /* Run as restricted user */
if ((fd = open("/dev/null", O_RDONLY)) > 0)
{
dup2(fd, 0); /* </dev/null */
close(fd);
}
dup2(fds[1], 1); /* >pipe */
close(fds[1]);
cupsdExec(command, argv);
exit(errno);
}
/*
* Parent comes here, open the input side of the pipe...
*/
close(fds[1]);
return (cupsFileOpenFd(fds[0], "r"));
}
cups_file_t * /* O - CUPS file or @code NULL@ if the file or socket cannot be opened */
cupsFileOpen(const char *filename, /* I - Name of file */
const char *mode) /* I - Open mode */
{
cups_file_t *fp; /* New CUPS file */
int fd; /* File descriptor */
char hostname[1024], /* Hostname */
*portname; /* Port "name" (number or service) */
http_addrlist_t *addrlist; /* Host address list */
DEBUG_printf(("cupsFileOpen(filename=\"%s\", mode=\"%s\")", filename,
mode));
/*
* Range check input...
*/
if (!filename || !mode ||
(*mode != 'r' && *mode != 'w' && *mode != 'a' && *mode != 's') ||
(*mode == 'a' && isdigit(mode[1] & 255)))
return (NULL);
/*
* Open the file...
*/
switch (*mode)
{
case 'a' : /* Append file */
fd = cups_open(filename,
O_RDWR | O_CREAT | O_APPEND | O_LARGEFILE | O_BINARY);
break;
case 'r' : /* Read file */
fd = open(filename, O_RDONLY | O_LARGEFILE | O_BINARY, 0);
break;
case 'w' : /* Write file */
fd = cups_open(filename, O_WRONLY | O_LARGEFILE | O_BINARY);
if (fd < 0 && errno == ENOENT)
{
fd = cups_open(filename,
O_WRONLY | O_CREAT | O_EXCL | O_LARGEFILE | O_BINARY);
if (fd < 0 && errno == EEXIST)
fd = cups_open(filename, O_WRONLY | O_LARGEFILE | O_BINARY);
}
if (fd >= 0)
#ifdef WIN32
_chsize(fd, 0);
#else
ftruncate(fd, 0);
#endif /* WIN32 */
break;
case 's' : /* Read/write socket */
strlcpy(hostname, filename, sizeof(hostname));
if ((portname = strrchr(hostname, ':')) != NULL)
*portname++ = '\0';
else
return (NULL);
/*
* Lookup the hostname and service...
*/
if ((addrlist = httpAddrGetList(hostname, AF_UNSPEC, portname)) == NULL)
return (NULL);
/*
* Connect to the server...
*/
if (!httpAddrConnect(addrlist, &fd))
{
httpAddrFreeList(addrlist);
return (NULL);
}
httpAddrFreeList(addrlist);
break;
default : /* Remove bogus compiler warning... */
return (NULL);
}
if (fd < 0)
return (NULL);
/*
* Create the CUPS file structure...
*/
if ((fp = cupsFileOpenFd(fd, mode)) == NULL)
{
if (*mode == 's')
closesocket(fd);
else
close(fd);
}
/*
* Return it...
*/
return (fp);
}
cups_file_t * /* O - CUPS file */
pipe_sendmail(const char *to) /* I - To: address */
{
cups_file_t *fp; /* CUPS file */
int pid; /* Process ID */
int pipefds[2]; /* Pipe file descriptors */
int argc; /* Number of arguments */
char *argv[100], /* Argument array */
line[1024], /* Sendmail command + args */
*lineptr; /* Pointer into line */
/*
* First break the mailtoSendmail string into arguments...
*/
strlcpy(line, mailtoSendmail, sizeof(line));
argv[0] = line;
argc = 1;
for (lineptr = strchr(line, ' '); lineptr; lineptr = strchr(lineptr, ' '))
{
while (*lineptr == ' ')
*lineptr++ = '\0';
if (*lineptr)
{
/*
* Point to the next argument...
*/
argv[argc ++] = lineptr;
/*
* Stop if we have too many...
*/
if (argc >= (int)(sizeof(argv) / sizeof(argv[0]) - 2))
break;
}
}
argv[argc ++] = (char *)to;
argv[argc] = NULL;
/*
* Create the pipe...
*/
if (pipe(pipefds))
{
perror("ERROR: Unable to create pipe");
return (NULL);
}
/*
* Then run the command...
*/
if ((pid = fork()) == 0)
{
/*
* Child goes here - redirect stdin to the input side of the pipe,
* redirect stdout to stderr, and exec...
*/
close(0);
dup(pipefds[0]);
close(1);
dup(2);
close(pipefds[0]);
close(pipefds[1]);
execvp(argv[0], argv);
exit(errno);
}
else if (pid < 0)
{
/*
* Unable to fork - error out...
*/
perror("ERROR: Unable to fork command");
close(pipefds[0]);
close(pipefds[1]);
return (NULL);
}
/*
* Create a CUPS file using the output side of the pipe and close the
* input side...
*/
close(pipefds[0]);
if ((fp = cupsFileOpenFd(pipefds[1], "w")) == NULL)
{
int status; /* Status of command */
close(pipefds[1]);
wait(&status);
}
return (fp);
}