static int attach_binary_item(struct abrt_xmlrpc *ax, const char *bug_id, const char *item_name, struct problem_item *item) { if (!(item->flags & CD_FLAG_BIN)) return 0; char *filename = item->content; int fd = open(filename, O_RDONLY); if (fd < 0) { perror_msg("Can't open '%s'", filename); return 0; } errno = 0; struct stat st; if (fstat(fd, &st) != 0 || !S_ISREG(st.st_mode)) { perror_msg("'%s': not a regular file", filename); close(fd); return 0; } VERB3 log("attaching '%s' as binary", item_name); int r = rhbz_attach_fd(ax, bug_id, item_name, fd, RHBZ_NOMAIL_NOTIFY | RHBZ_BINARY_ATTACHMENT); close(fd); return (r == 0); }
void select_playtgt (dspdev_t * dsp) { /* * Handling of the -o command line option (playback target selection). * * Empty or "?" shows the available playback sources. */ int i, src; oss_mixer_enuminfo ei; if (ioctl (dsp->fd, SNDCTL_DSP_GET_PLAYTGT_NAMES, &ei) == -1) { perror_msg ("SNDCTL_DSP_GET_PLAYTGT_NAMES"); exit (E_SETUP_ERROR); } if (ioctl (dsp->fd, SNDCTL_DSP_GET_PLAYTGT, &src) == -1) { perror_msg ("SNDCTL_DSP_GET_PLAYTGT"); exit (E_SETUP_ERROR); } if ((dsp->playtgt[0] == '\0') || (strcmp (dsp->playtgt, "?") == 0)) { print_msg (STARTM, "\nPossible playback targets for the selected device:\n\n"); for (i = 0; i < ei.nvalues; i++) { print_msg (CONTM, "\t%s", ei.strings + ei.strindex[i]); if (i == src) print_msg (CONTM, " (currently selected)"); print_msg (CONTM, "\n"); } print_msg (ENDM, "\n"); exit (0); } for (i = 0; i < ei.nvalues; i++) { char *s = ei.strings + ei.strindex[i]; if (strcmp (s, dsp->playtgt) == 0) { src = i; if (ioctl (dsp->fd, SNDCTL_DSP_SET_PLAYTGT, &src) == -1) { perror_msg ("SNDCTL_DSP_SET_PLAYTGT"); exit (E_SETUP_ERROR); } return; } } print_msg (ERRORM, "Unknown playback target name '%s' - use -o? to get the list\n", dsp->playtgt); exit (E_USAGE); }
/** * Produce an IN_CREATE notification for a new file and start wathing on it. * * This function is used as a callback and is invoked from the dep-list * routines. * * @param[in] udata A pointer to user data (#handle_context). * @param[in] path File name of a new file. * @param[in] inode Inode number of a new file. **/ static void handle_added (void *udata, const char *path, ino_t inode) { assert (udata != NULL); handle_context *ctx = (handle_context *) udata; assert (ctx->wrk != NULL); assert (ctx->w != NULL); assert (ctx->be != NULL); struct inotify_event *ie = NULL; int ie_len = 0; ie = create_inotify_event (ctx->w->fd, IN_CREATE, 0, path, &ie_len); if (ie != NULL) { bulk_write (ctx->be, ie, ie_len); free (ie); } else { perror_msg ("Failed to create an IN_CREATE event for %s", path); } char *npath = path_concat (ctx->w->filename, path); if (npath != NULL) { watch *neww = worker_start_watching (ctx->wrk, npath, path, ctx->w->flags, WATCH_DEPENDENCY); if (neww == NULL) { perror_msg ("Failed to start watching on a new dependency %s", npath); } else { neww->parent = ctx->w; } free (npath); } else { perror_msg ("Failed to allocate a path to start watching a dependency"); } }
int decompress_file(const char *path_in, const char *path_out, mode_t mode_out) { int fdi = open(path_in, O_RDONLY | O_CLOEXEC); if (fdi < 0) { perror_msg("Could not open file: %s", path_in); return -1; } int fdo = open(path_out, O_WRONLY | O_CLOEXEC | O_EXCL | O_CREAT, mode_out); if (fdo < 0) { close(fdi); perror_msg("Could not create file: %s", path_out); return -1; } int ret = decompress_fd(fdi, fdo); close(fdi); close(fdo); if (ret != 0) unlink(path_out); return ret; }
void select_recsrc (dspdev_t * dsp) { /* * Handling of the -i command line option (recording source selection). * * Empty or "?" shows the available recording sources. */ int i, src; oss_mixer_enuminfo ei; if (ioctl (dsp->fd, SNDCTL_DSP_GET_RECSRC_NAMES, &ei) == -1) { perror_msg ("SNDCTL_DSP_GET_RECSRC_NAMES"); exit (E_SETUP_ERROR); } if (ioctl (dsp->fd, SNDCTL_DSP_GET_RECSRC, &src) == -1) { perror_msg ("SNDCTL_DSP_GET_RECSRC"); exit (E_SETUP_ERROR); } if (dsp->recsrc[0] == '\0' || strcmp (dsp->recsrc, "?") == 0) { print_msg (STARTM, "\nPossible recording sources for the selected device:\n\n"); for (i = 0; i < ei.nvalues; i++) { print_msg (CONTM, "\t%s", ei.strings + ei.strindex[i]); if (i == src) print_msg (CONTM, " (currently selected)"); print_msg (CONTM, "\n"); } print_msg (ENDM, "\n"); exit (0); } for (i = 0; i < ei.nvalues; i++) { char *s = ei.strings + ei.strindex[i]; if (strcmp (s, dsp->recsrc) == 0) { src = i; if (ioctl (dsp->fd, SNDCTL_DSP_SET_RECSRC, &src) == -1) { perror_msg ("SNDCTL_DSP_SET_RECSRC"); exit (E_SETUP_ERROR); } return; } } print_msg (ERRORM, "Unknown recording source name '%s' - use -i? to get the list\n", dsp->recsrc); exit (E_USAGE); }
/* Return values: * -1: error (in this case, errno is 0 if error message is already logged) * 0: failed to lock (someone else has it locked) * 1: success */ int create_symlink_lockfile(const char* lock_file, const char* pid) { while (symlink(pid, lock_file) != 0) { if (errno != EEXIST) { if (errno != ENOENT && errno != ENOTDIR && errno != EACCES) { perror_msg("Can't create lock file '%s'", lock_file); errno = 0; } return -1; } char pid_buf[sizeof(pid_t)*3 + 4]; ssize_t r = readlink(lock_file, pid_buf, sizeof(pid_buf) - 1); if (r < 0) { if (errno == ENOENT) { /* Looks like lock_file was deleted */ usleep(SYMLINK_RETRY_USLEEP); /* avoid CPU eating loop */ continue; } perror_msg("Can't read lock file '%s'", lock_file); errno = 0; return -1; } pid_buf[r] = '\0'; if (strcmp(pid_buf, pid) == 0) { log("Lock file '%s' is already locked by us", lock_file); errno = EALREADY; return 0; } if (isdigit_str(pid_buf)) { char pid_str[sizeof("/proc/") + sizeof(pid_buf)]; snprintf(pid_str, sizeof(pid_str), "/proc/%s", pid_buf); if (access(pid_str, F_OK) == 0) { log("Lock file '%s' is locked by process %s", lock_file, pid_buf); return 0; } log("Lock file '%s' was locked by process %s, but it crashed?", lock_file, pid_buf); } /* The file may be deleted by now by other process. Ignore ENOENT */ if (unlink(lock_file) != 0 && errno != ENOENT) { perror_msg("Can't remove stale lock file '%s'", lock_file); errno = 0; return -1; } } log_info("Locked '%s'", lock_file); return 1; }
/* Callback called by glib main loop when a client connects to ABRT's socket. */ static gboolean server_socket_cb(GIOChannel *source, GIOCondition condition, gpointer ptr_unused) { kill_idle_timeout(); load_abrt_conf(); int socket = accept(g_io_channel_unix_get_fd(source), NULL, NULL); if (socket == -1) { perror_msg("accept"); goto server_socket_finitio; } log_notice("New client connected"); fflush(NULL); /* paranoia */ int pipefd[2]; xpipe(pipefd); pid_t pid = fork(); if (pid < 0) { perror_msg("fork"); close(socket); close(pipefd[0]); close(pipefd[1]); goto server_socket_finitio; } if (pid == 0) /* child */ { xdup2(socket, STDIN_FILENO); xdup2(socket, STDOUT_FILENO); close(socket); close(pipefd[0]); xmove_fd(pipefd[1], STDERR_FILENO); char *argv[3]; /* abrt-server [-s] NULL */ char **pp = argv; *pp++ = (char*)"abrt-server"; if (logmode & LOGMODE_JOURNAL) *pp++ = (char*)"-s"; *pp = NULL; execvp(argv[0], argv); perror_msg_and_die("Can't execute '%s'", argv[0]); } /* parent */ close(socket); close(pipefd[1]); add_abrt_server_proc(pid, pipefd[0]); server_socket_finitio: start_idle_timeout(); return TRUE; }
/* The function expects that FILENAME_COUNT dump dir element is created by * abrtd after all post-create events are successfully done. Thus if * FILENAME_COUNT element doesn't exist abrtd can consider the dump directory * as unprocessed. * * Relying on content of dump directory has one problem. If a hook provides * FILENAME_COUNT abrtd will consider the dump directory as processed. */ static void mark_unprocessed_dump_dirs_not_reportable(const char *path) { log_notice("Searching for unprocessed dump directories"); DIR *dp = opendir(path); if (!dp) { perror_msg("Can't open directory '%s'", path); return; } struct dirent *dent; while ((dent = readdir(dp)) != NULL) { if (dot_or_dotdot(dent->d_name)) continue; /* skip "." and ".." */ char *full_name = concat_path_file(path, dent->d_name); struct stat stat_buf; if (stat(full_name, &stat_buf) != 0) { perror_msg("Can't access path '%s'", full_name); goto next_dd; } if (S_ISDIR(stat_buf.st_mode) == 0) /* This is expected. The dump location contains some aux files */ goto next_dd; struct dump_dir *dd = dd_opendir(full_name, /*flags*/0); if (dd) { if (!problem_dump_dir_is_complete(dd) && !dd_exist(dd, FILENAME_NOT_REPORTABLE)) { log_warning("Marking '%s' not reportable (no '"FILENAME_COUNT"' item)", full_name); dd_save_text(dd, FILENAME_NOT_REPORTABLE, _("The problem data are " "incomplete. This usually happens when a problem " "is detected while computer is shutting down or " "user is logging out. In order to provide " "valuable problem reports, ABRT will not allow " "you to submit this problem. If you have time and " "want to help the developers in their effort to " "sort out this problem, please contact them directly.")); } dd_close(dd); } next_dd: free(full_name); } closedir(dp); }
int uname_main(int argc, char **argv) { struct utsname name; char processor[256]; #if defined(__sparc__) && defined(__linux__) char *fake_sparc = getenv("FAKE_SPARC"); #endif toprint = 0; /* Parse any options */ //fprintf(stderr, "argc=%d, argv=%s\n", argc, *argv); while (--argc > 0 && **(++argv) == '-') { while (*(++(*argv))) { switch (**argv) { case 's': toprint |= PRINT_SYSNAME; break; case 'n': toprint |= PRINT_NODENAME; break; case 'r': toprint |= PRINT_RELEASE; break; case 'v': toprint |= PRINT_VERSION; break; case 'm': toprint |= PRINT_MACHINE; break; case 'p': toprint |= PRINT_PROCESSOR; break; case 'a': toprint = (PRINT_SYSNAME | PRINT_NODENAME | PRINT_RELEASE | PRINT_PROCESSOR | PRINT_VERSION | PRINT_MACHINE); break; default: show_usage(); } } } if (toprint == 0) toprint = PRINT_SYSNAME; if (uname(&name) == -1) perror_msg("cannot get system name"); #if defined (HAVE_SYSINFO) && defined (SI_ARCHITECTURE) if (sysinfo(SI_ARCHITECTURE, processor, sizeof(processor)) == -1) perror_msg("cannot get processor type"); }
static int decompress_using_fork_execvp(const char** cmd, int fdi, int fdo) { pid_t child = fork(); if (child < 0) { VERB1 perror_msg("fork() for decompression"); return -1; } if (child == 0) { close(STDIN_FILENO); if (dup2(fdi, STDIN_FILENO) < 0) { VERB1 perror_msg("Decompression failed: dup2(fdi, STDIN_FILENO)"); exit(EXIT_FAILURE); } close(STDOUT_FILENO); if (dup2(fdo, STDOUT_FILENO) < 0) { VERB1 perror_msg("Decompression failed: dup2(fdo, STDOUT_FILENO)"); exit(EXIT_FAILURE); } execvp(cmd[0], (char **)cmd); VERB1 perror_msg("Decompression failed: execlp('%s')", cmd[0]); exit(EXIT_FAILURE); } int status = 0; int r = safe_waitpid(child, &status, 0); if (r < 0) { VERB1 perror_msg("Decompression failed: waitpid($1) failed"); return -2; } if (!WIFEXITED(status)) { log_info("Decompression process returned abnormally"); return -3; } if (WEXITSTATUS(status) != 0) { log_info("Decompression process exited with %d", WEXITSTATUS(r)); return -4; } return 0; }
/** * Produce an IN_DELETE/IN_CREATE notifications pair for an overwritten file. * Reopen a watch for the overwritten file. * * This function is used as a callback and is invoked from the dep-list * routines. * * @param[in] udata A pointer to user data (#handle_context). * @param[in] path File name of the overwritten file. * @param[in] inode Inode number of the overwritten file. **/ static void handle_overwritten (void *udata, const char *path, ino_t inode) { assert (udata != NULL); handle_context *ctx = (handle_context *) udata; assert (ctx->wrk != NULL); assert (ctx->w != NULL); assert (ctx->be != NULL); int i; for (i = 0; i < ctx->wrk->sets.length; i++) { watch *wi = ctx->wrk->sets.watches[i]; if (wi && (strcmp (wi->filename, path) == 0) && wi->parent == ctx->w) { if (watch_reopen (wi) == -1) { /* I dont know, what to do */ /* Not a very beautiful way to remove a single dependency */ dep_list *dl = dl_create (wi->filename, wi->inode); worker_remove_many (ctx->wrk, ctx->w, dl, 0); dl_shallow_free (dl); } else { uint32_t cookie = inode & 0x00000000FFFFFFFF; int event_len = 0; struct inotify_event *ev; ev = create_inotify_event (ctx->w->fd, IN_DELETE, cookie, path, &event_len); if (ev != NULL) { bulk_write (ctx->be, ev, event_len); free (ev); } else { perror_msg ("Failed to create an IN_DELETE event (*) for %s", path); } ev = create_inotify_event (ctx->w->fd, IN_CREATE, cookie, path, &event_len); if (ev != NULL) { bulk_write (ctx->be, ev, event_len); free (ev); } else { perror_msg ("Failed to create an IN_CREATE event (*) for %s", path); } } break; } } }
/** * Produce an IN_MOVED_FROM/IN_MOVED_TO notifications pair for a replaced file. * Also stops wathing on the replaced file. * * This function is used as a callback and is invoked from the dep-list * routines. * * @param[in] udata A pointer to user data (#handle_context). * @param[in] from_path File name of the source file. * @param[in] from_inode Inode number of the source file. * @param[in] to_path File name of the replaced file. * @param[in] to_inode Inode number of the replaced file. **/ static void handle_replaced (void *udata, const char *from_path, ino_t from_inode, const char *to_path, ino_t to_inode) { assert (udata != NULL); handle_context *ctx = (handle_context *) udata; assert (ctx->wrk != NULL); assert (ctx->w != NULL); assert (ctx->be != NULL); uint32_t cookie = from_inode & 0x00000000FFFFFFFF; int event_len = 0; struct inotify_event *ev; ev = create_inotify_event (ctx->w->fd, IN_MOVED_FROM, cookie, from_path, &event_len); if (ev != NULL) { bulk_write (ctx->be, ev, event_len); free (ev); } else { perror_msg ("Failed to create an IN_MOVED_FROM event (*) for %s", from_path); } ev = create_inotify_event (ctx->w->fd, IN_MOVED_TO, cookie, to_path, &event_len); if (ev != NULL) { bulk_write (ctx->be, ev, event_len); free (ev); } else { perror_msg ("Failed to create an IN_MOVED_TO event (*) for %s", to_path); } int i; for (i = 1; i < ctx->wrk->sets.length; i++) { watch *iw = ctx->wrk->sets.watches[i]; if (iw && iw->parent == ctx->w && strcmp (to_path, iw->filename) == 0) { dep_list *dl = dl_create (iw->filename, iw->inode); worker_remove_many (ctx->wrk, ctx->w, dl, 0); dl_shallow_free (dl); break; } } }
static int create_pidfile(void) { /* Note: * No O_EXCL: we would happily overwrite stale pidfile from previous boot. * No O_TRUNC: we must first try to lock the file, and if lock fails, * there is another live abrtd. O_TRUNCing the file in this case * would be wrong - it'll erase the pid to empty string! */ int fd = open(VAR_RUN_PIDFILE, O_RDWR|O_CREAT, 0644); if (fd >= 0) { if (lockf(fd, F_TLOCK, 0) < 0) { perror_msg("Can't lock file '%s'", VAR_RUN_PIDFILE); /* should help with problems like rhbz#859724 */ char pid_str[sizeof(long)*3 + 4]; int r = full_read(fd, pid_str, sizeof(pid_str)); close(fd); /* File can contain garbage. Be careful interpreting it as PID */ if (r > 0) { pid_str[r] = '\0'; errno = 0; long locking_pid = strtol(pid_str, NULL, 10); if (!errno && locking_pid > 0 && locking_pid <= INT_MAX) { char *cmdline = get_cmdline(locking_pid); if (cmdline) { error_msg("Process %lu '%s' is holding the lock", locking_pid, cmdline); free(cmdline); } } } return -1; } close_on_exec_on(fd); /* write our pid to it */ char buf[sizeof(long)*3 + 2]; int len = sprintf(buf, "%lu\n", (long)getpid()); IGNORE_RESULT(write(fd, buf, len)); IGNORE_RESULT(ftruncate(fd, len)); /* we leak opened+locked fd intentionally */ return 0; } perror_msg("Can't open '%s'", VAR_RUN_PIDFILE); return -1; }
int gz_close(int gunzip_pid) { int status; int ret; if (gz_use_vfork) { /* The gunzip process remains running in the background if we * used the vfork()/exec() technique - so we have to kill it * forcibly. There might be a better way to do this, but that * affect a lot of other parts of opkg, and this works fine. */ if (kill(gunzip_pid, SIGTERM) == -1) { perror_msg("gz_close(): unable to kill gunzip pid."); return -1; } } if (waitpid(gunzip_pid, &status, 0) == -1) { perror_msg("waitpid"); return -1; } if (gz_use_vfork) { /* Bail out here if we used the vfork()/exec() technique. */ return 0; } if (WIFSIGNALED(status)) { error_msg("Unzip process killed by signal %d.\n", WTERMSIG(status)); return -1; } if (!WIFEXITED(status)) { /* shouldn't happen */ error_msg("Your system is broken: got status %d from waitpid.\n", status); return -1; } if ((ret = WEXITSTATUS(status))) { error_msg("Unzip process failed with return code %d.\n", ret); return -1; } return 0; }
// Update attribute of given file. static int update_attr(struct dirtree *root) { unsigned long fval = 0; char *fpath = NULL; int fd; if (!dirtree_notdotdot(root)) return 0; /* * if file is a link and recursive is set or file is not regular+link+dir * (like fifo or dev file) then escape the file. */ if ((S_ISLNK(root->st.st_mode) && chattr.recursive) || (!S_ISREG(root->st.st_mode) && !S_ISLNK(root->st.st_mode) && !S_ISDIR(root->st.st_mode))) return 0; fpath = dirtree_path(root, NULL); if (-1 == (fd=open(fpath, O_RDONLY | O_NONBLOCK))) { free(fpath); return DIRTREE_ABORT; } // Get current attr of file. if (ext2_getflag(fd, &(root->st), &fval) < 0) { perror_msg("read flags of '%s'", fpath); free(fpath); xclose(fd); return DIRTREE_ABORT; } if (chattr.set) { // for '=' operator. if (ext2_setflag(fd, &(root->st), chattr.set) < 0) perror_msg("setting flags '%s'", fpath); } else { // for '-' / '+' operator. fval &= ~(chattr.rm); fval |= chattr.add; if (!S_ISDIR(root->st.st_mode)) fval &= ~FS_DIRSYNC_FL; if (ext2_setflag(fd, &(root->st), fval) < 0) perror_msg("setting flags '%s'", fpath); } if (chattr.vflag) { // set file version if (ioctl(fd, FS_IOC_SETVERSION, (void*)&chattr.version) < 0) perror_msg("while setting version on '%s'", fpath); } free(fpath); xclose(fd); if (S_ISDIR(root->st.st_mode) && chattr.recursive) return DIRTREE_RECURSE; return 0; }
static void print_file_attr(char *path) { unsigned long flag = 0, version = 0; int fd; struct stat sb; if (!stat(path, &sb) && !S_ISREG(sb.st_mode) && !S_ISDIR(sb.st_mode)) { errno = EOPNOTSUPP; goto LABEL1; } if (-1 == (fd=open(path, O_RDONLY | O_NONBLOCK))) goto LABEL1; if (toys.optflags & FLAG_v) { if (ioctl(fd, FS_IOC_GETVERSION, (void*)&version) < 0) goto LABEL2; xprintf("%5lu ", version); } if (ext2_getflag(fd, &sb, &flag) < 0) perror_msg("reading flags '%s'", path); else { struct ext2_attr *ptr = e2attrs; if (toys.optflags & FLAG_l) { int name_found = 0; xprintf("%-50s ", path); for (; ptr->name; ptr++) { if (flag & ptr->flag) { if (name_found) xprintf(", "); //for formatting. xprintf("%s", ptr->name); name_found = 1; } } if (!name_found) xprintf("---"); xputc('\n'); } else { int index = 0; for (; ptr->name; ptr++) toybuf[index++] = (flag & ptr->flag) ? ptr->opt : '-'; toybuf[index] = '\0'; xprintf("%s %s\n", toybuf, path); } } xclose(fd); return; LABEL2: xclose(fd); LABEL1: perror_msg("reading '%s'", path); }
static void find_devname (char * devname, const char * num) { /* * OSS 4.0 the audio device numbering may be different from the * legacy /dev/dsp# numbering reported by /dev/sndstat. Try to find the * device name (devnode) that matches the given device number. * * Prior versions of ossplay simply used the the /dev/dsp# number. */ int dev; int mixer_fd; oss_audioinfo ai; const char * devmixer; if ((devmixer = getenv("OSS_MIXERDEV")) == NULL) devmixer = "/dev/mixer"; if (sscanf (num, "%d", &dev) != 1) { print_msg (ERRORM, "Invalid audio device number '%s'\n", num); exit (E_SETUP_ERROR); } if ((mixer_fd = open (devmixer, O_RDWR, 0)) == -1) { perror_msg (devmixer); print_msg (WARNM, "Warning: Defaulting to /dev/dsp%s\n", num); snprintf (devname, OSS_DEVNODE_SIZE, "/dev/dsp%s", num); return; } ai.dev = dev; if (ioctl (mixer_fd, SNDCTL_AUDIOINFO, &ai) == -1) { perror_msg ("SNDCTL_AUDIOINFO"); print_msg (WARNM, "Warning: Defaulting to /dev/dsp%s\n", num); snprintf (devname, OSS_DEVNODE_SIZE, "/dev/dsp%s", num); close (mixer_fd); return; } strncpy (devname, ai.devnode, OSS_DEVNODE_SIZE); close (mixer_fd); return; }
static void do_loadfont(int fd, char *inbuf, int unit, int fontsize) { char buf[16384]; int i; memset(buf, 0, sizeof(buf)); if (unit < 1 || unit > 32) error_msg_and_die("Bad character size %d", unit); for (i = 0; i < fontsize; i++) memcpy(buf + (32 * i), inbuf + (unit * i), unit); #if defined( PIO_FONTX ) && !defined( __sparc__ ) { struct consolefontdesc cfd; cfd.charcount = fontsize; cfd.charheight = unit; cfd.chardata = buf; if (ioctl(fd, PIO_FONTX, &cfd) == 0) return; /* success */ perror_msg("PIO_FONTX ioctl error (trying PIO_FONT)"); } #endif if (ioctl(fd, PIO_FONT, buf)) perror_msg_and_die("PIO_FONT ioctl error"); }
char * xgetcwd (char *cwd) { char *ret; unsigned path_max; path_max = (unsigned) PATH_MAX; path_max += 2; /* The getcwd docs say to do this. */ if(cwd==0) cwd = xmalloc (path_max); while ((ret = getcwd (cwd, path_max)) == NULL && errno == ERANGE) { path_max += PATH_INCR; cwd = xrealloc (cwd, path_max); } if (ret == NULL) { free (cwd); perror_msg("getcwd()"); return NULL; } return cwd; }
static int tarExtractSymLink(TarInfo *header, int extractFlag, int tostdoutFlag) { if (extractFlag==FALSE || tostdoutFlag==TRUE) return( TRUE); #ifdef S_ISLNK if (symlink(header->linkname, header->name) < 0) { perror_msg("%s: Cannot create symlink to '%s'", header->name, header->linkname); return( FALSE); } /* Try to change ownership of the symlink. * If libs doesn't support that, don't bother. * Changing the pointed-to-file is the Wrong Thing(tm). */ #if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1) lchown(header->name, header->uid, header->gid); #endif /* Do not change permissions or date on symlink, * since it changes the pointed to file instead. duh. */ #else error_msg("%s: Cannot create symlink to '%s': %s", header->name, header->linkname, "symlinks not supported"); #endif return( TRUE); }
bool dir_is_in_dump_location(const char *dir_name) { unsigned len = strlen(g_settings_dump_location); /* The path must start with "g_settings_dump_location" */ if (strncmp(dir_name, g_settings_dump_location, len) != 0) { log_debug("Bad parent directory: '%s' not in '%s'", g_settings_dump_location, dir_name); return false; } /* and must be a sub-directory of the g_settings_dump_location dir */ const char *base_name = dir_name + len; while (*base_name && *base_name == '/') ++base_name; if (*(base_name - 1) != '/' || !str_is_correct_filename(base_name)) { log_debug("Invalid dump directory name: '%s'", base_name); return false; } /* and we are sure it is a directory */ struct stat sb; if (lstat(dir_name, &sb) < 0) { VERB2 perror_msg("stat('%s')", dir_name); return errno== ENOENT; } return S_ISDIR(sb.st_mode); }
void open_device (dspdev_t * dsp) { const char * devdsp; if (dsp->fd >= 0) close_device (dsp); dsp->format = 0; dsp->channels = 0; dsp->speed = 0; if ((devdsp = getenv("OSS_AUDIODEV")) == NULL) devdsp = "/dev/dsp"; if (raw_mode) dsp->flags |= O_EXCL; /* Disable redirection to the virtual mixer */ if (dsp->dname[0] == '\0') strcpy (dsp->dname, devdsp); if ((dsp->fd = open (dsp->dname, dsp->flags, 0)) == -1) { perror_msg (dsp->dname); describe_error (); exit (E_SETUP_ERROR); } if (raw_mode) { /* * Disable sample rate/format conversions. */ int tmp = 0; ioctl (dsp->fd, SNDCTL_DSP_COOKEDMODE, &tmp); } }
void do_id(char *username) { int flags, i, ngroups, cmd_groups = toys.which->name[0] == 'g'; struct passwd *pw; struct group *grp; uid_t uid = getuid(), euid = geteuid(); gid_t gid = getgid(), egid = getegid(), *groups; if (cmd_groups) toys.optflags |= FLAG_G | FLAG_n; flags = toys.optflags; // check if a username is given if (username) { pw = xgetpwnam(username); uid = euid = pw->pw_uid; gid = egid = pw->pw_gid; if (cmd_groups) printf("%s : ", pw->pw_name); } i = flags & FLAG_r; pw = xgetpwuid(i ? uid : euid); if (flags & FLAG_u) s_or_u(pw->pw_name, pw->pw_uid, 1); grp = xgetgrgid(i ? gid : egid); if (flags & FLAG_g) s_or_u(grp->gr_name, grp->gr_gid, 1); if (!(flags & FLAG_G)) { showid("uid=", pw->pw_uid, pw->pw_name); showid(" gid=", grp->gr_gid, grp->gr_name); if (!i) { if (uid != euid) { pw = xgetpwuid(euid); showid(" euid=", pw->pw_uid, pw->pw_name); } if (gid != egid) { grp = xgetgrgid(egid); showid(" egid=", grp->gr_gid, grp->gr_name); } } showid(" groups=", grp->gr_gid, grp->gr_name); } groups = (gid_t *)toybuf; i = sizeof(toybuf)/sizeof(gid_t); ngroups = username ? getgrouplist(username, gid, groups, &i) : getgroups(i, groups); if (ngroups<0) perror_exit(0); for (i = 0; i<ngroups; i++) { if (i) xputc(' '); if (!(grp = getgrgid(groups[i]))) perror_msg(0); else if (flags & FLAG_G) s_or_u(grp->gr_name, grp->gr_gid, 0); else if (grp->gr_gid != egid) showid("", grp->gr_gid, grp->gr_name); } xputc('\n'); }
static int rm_Action(const char *fileName, struct stat *statbuf, void* junk) { int status = TRUE; if (S_ISDIR(statbuf->st_mode)) { if (rmdir(fileName) < 0) { perror_msg("rmdir(%s)", fileName); status = FALSE; } } else if (unlink(fileName) < 0) { perror_msg("unlink(%s)", fileName); status = FALSE; } return status; }
static void notify_next_post_create_process(struct abrt_server_proc *finished) { if (finished != NULL) s_dir_queue = g_list_remove(s_dir_queue, finished); while (s_dir_queue != NULL) { struct abrt_server_proc *n = (struct abrt_server_proc *)s_dir_queue->data; if (n->type == AS_POST_CREATE) break; if (kill(n->pid, SIGUSR1) >= 0) { n->type = AS_POST_CREATE; break; } /* This could happen only if the notified process disappeared - crashed? */ perror_msg("Failed to send SIGUSR1 to %d", n->pid); log_warning("Directory '%s' will not be processed", n->dirname); /* Remove the problematic process from the post-crate directory queue * and go to try to notify another process. */ s_dir_queue = g_list_delete_link(s_dir_queue, s_dir_queue); } }
/* create (sym)links for each applet */ static void install_links(const char *busybox, int use_symbolic_links) { __link_f Link = link; #ifdef ACTION_TEC_DIFFSERV char command[1024]; #else char command[256]; #endif //ACTION_TEC_DIFFSERV int i; int rc; if (use_symbolic_links) Link = symlink; for (i = 0; applets[i].name != NULL; i++) { sprintf ( command, "%s/%s", install_dir[applets[i].location], applets[i].name); rc = Link(busybox, command); if (rc) { perror_msg("%s", command); } } }
/* * Where in the filesystem is this busybox? * [return] * malloc'd string w/ full pathname of busybox's location * NULL on failure */ static char *busybox_fullpath() { pid_t pid; #ifdef ACTION_TEC_DIFFSERV char path[1024]; #else char proc[256]; #endif //ACTION_TEC_DIFFSERV int len; pid = getpid(); sprintf(proc, "/proc/%d/exe", pid); #ifdef ACTION_TEC_DIFFSERV len = readlink(proc, path, 1024); #else len = readlink(proc, path, 256); #endif// ACTION_TEC_DIFFSERV if (len != -1) { path[len] = 0; } else { perror_msg("%s", proc); return NULL; } return strdup(path); }
// Warn if we can't open a file and return a fd. int open3_or_warn(const char *pathname, int flags, int mode) { int ret; ret = open(pathname, flags, mode); if (ret < 0) perror_msg("Can't open '%s'", pathname); return ret; }
static int writeTarFile(const char* tarName, int verboseFlag, char **argv, char** excludeList) { int tarFd=-1; int errorFlag=FALSE; ssize_t size; struct TarBallInfo tbInfo; tbInfo.verboseFlag = verboseFlag; tbInfo.hlInfoHead = NULL; /* Make sure there is at least one file to tar up. */ if (*argv == NULL) error_msg_and_die("Cowardly refusing to create an empty archive"); /* Open the tar file for writing. */ if (!strcmp(tarName, "-")) tbInfo.tarFd = fileno(stdout); else tbInfo.tarFd = open (tarName, O_WRONLY | O_CREAT | O_TRUNC, 0644); if (tbInfo.tarFd < 0) { perror_msg( "Error opening '%s'", tarName); freeHardLinkInfo(&tbInfo.hlInfoHead); return ( FALSE); } tbInfo.excludeList=excludeList; /* Store the stat info for the tarball's file, so * can avoid including the tarball into itself.... */ if (fstat(tbInfo.tarFd, &tbInfo.statBuf) < 0) error_msg_and_die(io_error, tarName, strerror(errno)); /* Read the directory/files and iterate over them one at a time */ while (*argv != NULL) { if (recursive_action(*argv++, TRUE, FALSE, FALSE, writeFileToTarball, writeFileToTarball, (void*) &tbInfo) == FALSE) { errorFlag = TRUE; } } /* Write two empty blocks to the end of the archive */ for (size=0; size<(2*TAR_BLOCK_SIZE); size++) { write(tbInfo.tarFd, "\0", 1); } /* To be pedantically correct, we would check if the tarball * is smaller than 20 tar blocks, and pad it if it was smaller, * but that isn't necessary for GNU tar interoperability, and * so is considered a waste of space */ /* Hang up the tools, close up shop, head home */ close(tarFd); if (errorFlag == TRUE) { error_msg("Error exit delayed from previous errors"); freeHardLinkInfo(&tbInfo.hlInfoHead); return(FALSE); } freeHardLinkInfo(&tbInfo.hlInfoHead); return( TRUE); }
FILE *wfopen(const char *path, const char *mode) { FILE *fp; if ((fp = fopen(path, mode)) == NULL) { perror_msg("%s", path); errno = 0; } return fp; }