/** * @brief Main function of whole server. * * @return EXIT_SUCCESS - when forked properly * @return EXIT_FAILURE - on error during server initialization * @return 0 - on application exit */ int main(void) { pid_t pid, sid; int fd; int ret = 0; struct sigaction sa; char buff[16] = {0}; sa.sa_handler = server_sig_handler; sigemptyset(&sa.sa_mask); sigaction(SIGTERM, &sa, NULL); openlog("ScopeServer", LOG_PID | LOG_LOCAL0, LOG_LOCAL0); pid = fork(); if(pid < 0) { syslog(LOG_ERR, "Fork failed, daemon couldn't start! (errno = %d)\n", -errno); return EXIT_FAILURE; } else if(pid > 0){ return EXIT_SUCCESS; } openlog("ScopeServer", LOG_PID | LOG_LOCAL0, LOG_LOCAL0); umask(0); syslog(LOG_INFO, "[ScopeServer]: Daemon started!\n"); sid = setsid(); if(sid < 0) { syslog(LOG_ERR, "Setsid failed, couldn't create new sid! (errno = %d)\n", -errno); return EXIT_FAILURE; } sprintf(buff, "%ld", (long)getpid()); fd = open(SCOPE_FILE_PID, O_CREAT | O_WRONLY); if(fd <0) { syslog(LOG_ERR, "Couldn't create pid file! (errno = %d)\n", -errno); ret = EXIT_FAILURE; goto init_fail; } if(write(fd, buff, strlen(buff)+1) < 0) { syslog(LOG_ERR, "Couldn't save pid file for ScopeServer! (errno = %d)\n", -errno); close(fd); ret = EXIT_FAILURE; goto init_fail; } close(fd); if(mkfifo(SCOPE_FILE_FIFO, O_RDWR) < 0) { syslog(LOG_ERR, "Couldn't create fifo file: %s! (errno = %d)\n", SCOPE_FILE_FIFO, -errno); ret = EXIT_FAILURE; goto init_fail; } if(chdir("/") < 0) { syslog(LOG_ERR, "Chdir failed! (errno = %d)\n", -errno); ret = EXIT_FAILURE; goto init_fail; } close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO); if(server_init() < 0) { syslog(LOG_ERR, "Unable to initizalize the server! (errno = %d)\n", -errno); ret = EXIT_FAILURE; goto init_fail; } server_start(); init_fail: unlink(SCOPE_FILE_FIFO); unlink(SCOPE_FILE_PID); closelog(); return ret; }
/* dbgconnect(cProgramNname|nPid) -> lResult */ int clip_DBGCONNECT(ClipMachine * ClipMachineMemory) { #ifdef _WIN32 return EG_ARG; #else ClipVar *vp = _clip_par(ClipMachineMemory, 1); pid_t dpid = 0; if (!vp) return EG_ARG; if (vp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == NUMERIC_type_of_ClipVarType) dpid = _clip_double(vp); else if (vp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == CHARACTER_type_of_ClipVarType) { char path[256]; FILE *file; char *s = _clip_parc(ClipMachineMemory, 1); if (!s || !*s) return EG_ARG; snprintf(path, sizeof(path), "pidof -s %s", s); file = popen(path, "r"); if (file) { unsigned long ul; if (fscanf(file, "%lu", &ul) == 1) dpid = ul; pclose(file); } } if (!dpid) return EG_ARG; pid = dpid; if (!cleanup_installed) { cleanup_installed = 1; signal(SIGPIPE, dbg_signal); atexit(cleanup); } snprintf(in_path, sizeof(in_path), "/tmp/clip_dbg.%lu.in", (unsigned long) pid); remove(in_path); if (mkfifo(in_path, 0600)) { _clip_trap_printf(ClipMachineMemory, ClipMachineMemory->fp->filename_of_ClipFrame, ClipMachineMemory->fp->line_of_ClipFrame, "DBGCONNECT: cannot create FIFO '%s': %s\n", in_path, strerror(errno)); cleanup(); return -1; } _clip_logg(1, "fifo %s created successfully", in_path); snprintf(out_path, sizeof(out_path), "/tmp/clip_dbg.%lu.out", (unsigned long) pid); remove(out_path); if (mkfifo(out_path, 0600)) { _clip_trap_printf(ClipMachineMemory, ClipMachineMemory->fp->filename_of_ClipFrame, ClipMachineMemory->fp->line_of_ClipFrame, "DBGCONNECT: cannot create FIFO '%s': %s\n", out_path, strerror(errno)); cleanup(); return -1; } _clip_logg(1, "fifo %s created successfully", out_path); if (kill(pid, SIGUSR1)) { _clip_trap_printf(ClipMachineMemory, ClipMachineMemory->fp->filename_of_ClipFrame, ClipMachineMemory->fp->line_of_ClipFrame, "DBGCONNECT: cannot send signal SIGUSR1 to pid %lu: %s\n", (unsigned long) pid, strerror(errno)); cleanup(); return -1; } _clip_logg(1, "signal SIGUSR1 sent to pid %lu", (unsigned long) pid); fin = fopen(in_path, "wt"); if (!fin) { _clip_trap_printf(ClipMachineMemory, ClipMachineMemory->fp->filename_of_ClipFrame, ClipMachineMemory->fp->line_of_ClipFrame, "DBGCONNECT: cannot open FIFO '%s': %s\n", in_path, strerror(errno)); cleanup(); return -1; } setvbuf(fin, 0, _IOLBF, 0); fwrite("\n", 1, 1, fin); _clip_logg(1, "fifo %s opened for writing", in_path); fout = fopen(out_path, "rt"); if (!fout) { _clip_trap_printf(ClipMachineMemory, ClipMachineMemory->fp->filename_of_ClipFrame, ClipMachineMemory->fp->line_of_ClipFrame, "DBGCONNECT: cannot open FIFO '%s': %s\n", out_path, strerror(errno)); cleanup(); return -1; } /*setvbuf(fout, 0, _IOLBF, 0); */ _clip_logg(1, "fifo %s opened for reading", out_path); _clip_retl(ClipMachineMemory, 1); for (;;) { char buf[4096]; if (!fgets(buf, 4096, fout)) { _clip_trap_printf(ClipMachineMemory, ClipMachineMemory->fp->filename_of_ClipFrame, ClipMachineMemory->fp->line_of_ClipFrame, "DBGCOMMAND: cannot read data"); cleanup(); return -1; } if (!strcmp(buf, ".\n")) break; } return 0; #endif }
rtems_task Init( rtems_task_argument not_used ) { int fd = -1; int status = -1; off_t offset = 4; int pipe_length = -1; int flag = 1; puts( "\n\n*** TEST PIPE/FIFO - 04 ***" ); puts( "Init - Creating /fifo" ); status = mkfifo( "/fifo", 0777 ); rtems_test_assert( status == 0 ); puts( "Init - Opening /fifo in readonly, non-blocking mode" ); fd = open( "/fifo", O_RDONLY | O_NONBLOCK ); rtems_test_assert( fd != -1 ); puts( "Init - Attempt to lseek on fifo -- Expected ESPIPE" ); offset = lseek( fd, offset, SEEK_CUR ); rtems_test_assert( offset == -1 ); rtems_test_assert( errno == ESPIPE ); puts( "Init - ioctl: FIONBIO -- Expected EFAULT" ); status = ioctl( fd, FIONBIO, NULL ); rtems_test_assert( status == -1 ); rtems_test_assert( errno == EFAULT ); puts( "Init - ioctl: FIONBIO -- OK" ); status = ioctl( fd, FIONBIO, &flag ); rtems_test_assert( status == 0 ); flag = 0; puts( "Init - ioctl: FIONBIO -- OK" ); status = ioctl( fd, FIONBIO, &flag ); rtems_test_assert( status == 0 ); puts( "Init - ioctl: Dummy Command -- Expected EINVAL" ); status = ioctl( fd, -1, NULL ); rtems_test_assert( status == -1 ); rtems_test_assert( errno == EINVAL ); puts( "Init - ioctl: FIONREAD -- Expected EFAULT" ); status = ioctl( fd, FIONREAD, NULL ); rtems_test_assert( status == -1 ); rtems_test_assert( errno == EFAULT ); puts( "Init - ioctl: FIONREAD -- OK" ); status = ioctl( fd, FIONREAD, &pipe_length ); rtems_test_assert( status == 0 ); rtems_test_assert( pipe_length == 0 ); puts( "Init - closing /fifo" ); status = close( fd ); rtems_test_assert( status == 0 ); puts( "Init - removing /fifo" ); status = unlink( "/fifo" ); rtems_test_assert( status == 0 ); puts( "*** END OF TEST PIPE/FIFO - 04 ***" ); rtems_test_exit(0); }
/* * Create the file, or the directory * * fname is the original filename * ofile is the output filename (may be in a different directory) * * Returns: CF_SKIP if file should be skipped * CF_ERROR on error * CF_EXTRACT file created and data to restore * CF_CREATED file created no data to restore * * Note, we create the file here, except for special files, * we do not set the attributes because we want to first * write the file, then when the writing is done, set the * attributes. * * So, we return with the file descriptor open for normal files. */ int create_file(JCR *jcr, ATTR *attr, BFILE *bfd, int replace) { mode_t new_mode, parent_mode; int flags; uid_t uid; gid_t gid; int pnl; bool exists = false; struct stat mstatp; #ifndef HAVE_WIN32 bool isOnRoot; #endif bfd->reparse_point = false; if (is_win32_stream(attr->data_stream)) { set_win32_backup(bfd); } else { set_portable_backup(bfd); } new_mode = attr->statp.st_mode; Dmsg3(200, "type=%d newmode=%x file=%s\n", attr->type, new_mode, attr->ofname); parent_mode = S_IWUSR | S_IXUSR | new_mode; gid = attr->statp.st_gid; uid = attr->statp.st_uid; #ifdef HAVE_WIN32 if (!bfd->use_backup_api) { /* * Eliminate invalid windows filename characters from foreign filenames */ char *ch = (char *)attr->ofname; if (ch[0] != 0 && ch[1] != 0) { ch += 2; while (*ch) { switch (*ch) { case ':': case '<': case '>': case '*': case '?': case '|': *ch = '_'; break; } ch++; } } } #endif Dmsg2(400, "Replace=%c %d\n", (char)replace, replace); if (lstat(attr->ofname, &mstatp) == 0) { exists = true; switch (replace) { case REPLACE_IFNEWER: if (attr->statp.st_mtime <= mstatp.st_mtime) { Qmsg(jcr, M_INFO, 0, _("File skipped. Not newer: %s\n"), attr->ofname); return CF_SKIP; } break; case REPLACE_IFOLDER: if (attr->statp.st_mtime >= mstatp.st_mtime) { Qmsg(jcr, M_INFO, 0, _("File skipped. Not older: %s\n"), attr->ofname); return CF_SKIP; } break; case REPLACE_NEVER: /* * Set attributes if we created this directory */ if (attr->type == FT_DIREND && path_list_lookup(jcr->path_list, attr->ofname)) { break; } Qmsg(jcr, M_INFO, 0, _("File skipped. Already exists: %s\n"), attr->ofname); return CF_SKIP; case REPLACE_ALWAYS: break; } } switch (attr->type) { case FT_RAW: /* Raw device to be written */ case FT_FIFO: /* FIFO to be written to */ case FT_LNKSAVED: /* Hard linked, file already saved */ case FT_LNK: case FT_SPEC: /* Fifo, ... to be backed up */ case FT_REGE: /* Empty file */ case FT_REG: /* Regular file */ /* * Note, we do not delete FT_RAW because these are device files * or FIFOs that should already exist. If we blow it away, * we may blow away a FIFO that is being used to read the * restore data, or we may blow away a partition definition. */ if (exists && attr->type != FT_RAW && attr->type != FT_FIFO) { /* Get rid of old copy */ Dmsg1(400, "unlink %s\n", attr->ofname); if (secure_erase(jcr, attr->ofname) == -1) { berrno be; Qmsg(jcr, M_ERROR, 0, _("File %s already exists and could not be replaced. ERR=%s.\n"), attr->ofname, be.bstrerror()); /* Continue despite error */ } } /* * Here we do some preliminary work for all the above * types to create the path to the file if it does * not already exist. Below, we will split to * do the file type specific work */ pnl = separate_path_and_file(jcr, attr->fname, attr->ofname); if (pnl < 0) { return CF_ERROR; } /* * If path length is <= 0 we are making a file in the root * directory. Assume that the directory already exists. */ if (pnl > 0) { char savechr; savechr = attr->ofname[pnl]; attr->ofname[pnl] = 0; /* terminate path */ if (!path_already_seen(jcr, attr->ofname, pnl)) { Dmsg1(400, "Make path %s\n", attr->ofname); /* * If we need to make the directory, ensure that it is with * execute bit set (i.e. parent_mode), and preserve what already * exists. Normally, this should do nothing. */ if (!makepath(attr, attr->ofname, parent_mode, parent_mode, uid, gid, 1)) { Dmsg1(10, "Could not make path. %s\n", attr->ofname); attr->ofname[pnl] = savechr; /* restore full name */ return CF_ERROR; } } attr->ofname[pnl] = savechr; /* restore full name */ } /* * Now we do the specific work for each file type */ switch(attr->type) { case FT_REGE: case FT_REG: Dmsg1(100, "Create=%s\n", attr->ofname); flags = O_WRONLY | O_CREAT | O_TRUNC | O_BINARY; /* O_NOFOLLOW; */ if (IS_CTG(attr->statp.st_mode)) { flags |= O_CTG; /* set contiguous bit if needed */ } if (is_bopen(bfd)) { Qmsg1(jcr, M_ERROR, 0, _("bpkt already open fid=%d\n"), bfd->fid); bclose(bfd); } if (bopen(bfd, attr->ofname, flags, 0, attr->statp.st_rdev) < 0) { berrno be; be.set_errno(bfd->berrno); Qmsg2(jcr, M_ERROR, 0, _("Could not create %s: ERR=%s\n"), attr->ofname, be.bstrerror()); Dmsg2(100,"Could not create %s: ERR=%s\n", attr->ofname, be.bstrerror()); return CF_ERROR; } return CF_EXTRACT; #ifndef HAVE_WIN32 /* None of these exist in MS Windows */ case FT_RAW: /* Bareos raw device e.g. /dev/sda1 */ case FT_FIFO: /* Bareos fifo to save data */ case FT_SPEC: flags = O_WRONLY | O_BINARY; isOnRoot = bstrcmp(attr->fname, attr->ofname) ? 1 : 0; if (S_ISFIFO(attr->statp.st_mode)) { Dmsg1(400, "Restore fifo: %s\n", attr->ofname); if (mkfifo(attr->ofname, attr->statp.st_mode) != 0 && errno != EEXIST) { berrno be; Qmsg2(jcr, M_ERROR, 0, _("Cannot make fifo %s: ERR=%s\n"), attr->ofname, be.bstrerror()); return CF_ERROR; } } else if (S_ISSOCK(attr->statp.st_mode)) { Dmsg1(200, "Skipping restore of socket: %s\n", attr->ofname); #ifdef S_IFDOOR /* Solaris high speed RPC mechanism */ } else if (S_ISDOOR(attr->statp.st_mode)) { Dmsg1(200, "Skipping restore of door file: %s\n", attr->ofname); #endif #ifdef S_IFPORT /* Solaris event port for handling AIO */ } else if (S_ISPORT(attr->statp.st_mode)) { Dmsg1(200, "Skipping restore of event port file: %s\n", attr->ofname); #endif } else if ((S_ISBLK(attr->statp.st_mode) || S_ISCHR(attr->statp.st_mode)) && !exists && isOnRoot) { /* * Fatal: Restoring a device on root-file system, but device node does not exist. * Should not create a dump file. */ Qmsg1(jcr, M_ERROR, 0, _("Device restore on root failed, device %s missing.\n"), attr->fname); return CF_ERROR; } else if (S_ISBLK(attr->statp.st_mode) || S_ISCHR(attr->statp.st_mode)) { Dmsg1(400, "Restoring a device as a file: %s\n", attr->ofname); flags = O_WRONLY | O_CREAT | O_TRUNC | O_BINARY; } else { Dmsg1(400, "Restore node: %s\n", attr->ofname); if (mknod(attr->ofname, attr->statp.st_mode, attr->statp.st_rdev) != 0 && errno != EEXIST) { berrno be; Qmsg2(jcr, M_ERROR, 0, _("Cannot make node %s: ERR=%s\n"), attr->ofname, be.bstrerror()); return CF_ERROR; } } /* * Here we are going to attempt to restore to a FIFO, which * means that the FIFO must already exist, AND there must * be some process already attempting to read from the * FIFO, so we open it write-only. */ if (attr->type == FT_RAW || attr->type == FT_FIFO) { btimer_t *tid; Dmsg1(400, "FT_RAW|FT_FIFO %s\n", attr->ofname); /* * Timeout open() in 60 seconds */ if (attr->type == FT_FIFO) { Dmsg0(400, "Set FIFO timer\n"); tid = start_thread_timer(jcr, pthread_self(), 60); } else { tid = NULL; } if (is_bopen(bfd)) { Qmsg1(jcr, M_ERROR, 0, _("bpkt already open fid=%d\n"), bfd->fid); } Dmsg2(400, "open %s flags=0x%x\n", attr->ofname, flags); if ((bopen(bfd, attr->ofname, flags, 0, 0)) < 0) { berrno be; be.set_errno(bfd->berrno); Qmsg2(jcr, M_ERROR, 0, _("Could not open %s: ERR=%s\n"), attr->ofname, be.bstrerror()); Dmsg2(400, "Could not open %s: ERR=%s\n", attr->ofname, be.bstrerror()); stop_thread_timer(tid); return CF_ERROR; } stop_thread_timer(tid); return CF_EXTRACT; } Dmsg1(400, "FT_SPEC %s\n", attr->ofname); return CF_CREATED; case FT_LNKSAVED: /* Hard linked, file already saved */ Dmsg2(130, "Hard link %s => %s\n", attr->ofname, attr->olname); if (link(attr->olname, attr->ofname) != 0) { berrno be; #ifdef HAVE_CHFLAGS struct stat s; /* * If using BSD user flags, maybe has a file flag preventing this. * So attempt to disable, retry link, and reset flags. * Note that BSD securelevel may prevent disabling flag. */ if (stat(attr->olname, &s) == 0 && s.st_flags != 0) { if (chflags(attr->olname, 0) == 0) { if (link(attr->olname, attr->ofname) != 0) { /* * Restore original file flags even when linking failed */ if (chflags(attr->olname, s.st_flags) < 0) { Qmsg2(jcr, M_ERROR, 0, _("Could not restore file flags for file %s: ERR=%s\n"), attr->olname, be.bstrerror()); } #endif /* HAVE_CHFLAGS */ Qmsg3(jcr, M_ERROR, 0, _("Could not hard link %s -> %s: ERR=%s\n"), attr->ofname, attr->olname, be.bstrerror()); Dmsg3(200, "Could not hard link %s -> %s: ERR=%s\n", attr->ofname, attr->olname, be.bstrerror()); return CF_ERROR; #ifdef HAVE_CHFLAGS } /* * Finally restore original file flags */ if (chflags(attr->olname, s.st_flags) < 0) { Qmsg2(jcr, M_ERROR, 0, _("Could not restore file flags for file %s: ERR=%s\n"), attr->olname, be.bstrerror()); } } else { Qmsg2(jcr, M_ERROR, 0, _("Could not reset file flags for file %s: ERR=%s\n"), attr->olname, be.bstrerror()); } } else { Qmsg3(jcr, M_ERROR, 0, _("Could not hard link %s -> %s: ERR=%s\n"), attr->ofname, attr->olname, be.bstrerror()); return CF_ERROR; } #endif /* HAVE_CHFLAGS */ } return CF_CREATED; #endif /* HAVE_WIN32 */ #ifdef HAVE_WIN32 case FT_LNK: /* * Handle Windows Symlink-Like Reparse Points * - Directory Symlinks * - File Symlinks * - Volume Mount Points * - Junctions */ Dmsg2(130, "FT_LNK should restore: %s -> %s\n", attr->ofname, attr->olname); if (attr->statp.st_rdev & FILE_ATTRIBUTE_VOLUME_MOUNT_POINT) { /* * We do not restore volume mount points */ Dmsg0(130, "Skipping Volume Mount Point\n"); return CF_SKIP; } if (win32_symlink(attr->olname, attr->ofname, attr->statp.st_rdev) != 0 && errno != EEXIST) { berrno be; Qmsg3(jcr, M_ERROR, 0, _("Could not symlink %s -> %s: ERR=%s\n"), attr->ofname, attr->olname, be.bstrerror()); return CF_ERROR; } return CF_CREATED; #else case FT_LNK: /* * Unix/Linux symlink handling */ Dmsg2(130, "FT_LNK should restore: %s -> %s\n", attr->ofname, attr->olname); if (symlink(attr->olname, attr->ofname) != 0 && errno != EEXIST) { berrno be; Qmsg3(jcr, M_ERROR, 0, _("Could not symlink %s -> %s: ERR=%s\n"), attr->ofname, attr->olname, be.bstrerror()); return CF_ERROR; } return CF_CREATED; #endif } /* End inner switch */ case FT_REPARSE: case FT_JUNCTION: bfd->reparse_point = true; /* * Fall through wanted */ case FT_DIRBEGIN: case FT_DIREND: Dmsg2(200, "Make dir mode=%o dir=%s\n", new_mode, attr->ofname); if (!makepath(attr, attr->ofname, new_mode, parent_mode, uid, gid, 0)) { return CF_ERROR; } /* * If we are using the Win32 Backup API, we open the directory so * that the security info will be read and saved. */ if (!is_portable_backup(bfd)) { if (is_bopen(bfd)) { Qmsg1(jcr, M_ERROR, 0, _("bpkt already open fid=%d\n"), bfd->fid); } if (bopen(bfd, attr->ofname, O_WRONLY | O_BINARY, 0, attr->statp.st_rdev) < 0) { berrno be; be.set_errno(bfd->berrno); #ifdef HAVE_WIN32 /* * Check for trying to create a drive, if so, skip */ if (attr->ofname[1] == ':' && IsPathSeparator(attr->ofname[2]) && attr->ofname[3] == '\0') { return CF_SKIP; } #endif Qmsg2(jcr, M_ERROR, 0, _("Could not open %s: ERR=%s\n"), attr->ofname, be.bstrerror()); return CF_ERROR; } return CF_EXTRACT; } else { return CF_CREATED; } case FT_DELETED: Qmsg2(jcr, M_INFO, 0, _("Original file %s have been deleted: type=%d\n"), attr->fname, attr->type); break; /* * The following should not occur */ case FT_NOACCESS: case FT_NOFOLLOW: case FT_NOSTAT: case FT_DIRNOCHG: case FT_NOCHG: case FT_ISARCH: case FT_NORECURSE: case FT_NOFSCHG: case FT_NOOPEN: Qmsg2(jcr, M_ERROR, 0, _("Original file %s not saved: type=%d\n"), attr->fname, attr->type); break; default: Qmsg2(jcr, M_ERROR, 0, _("Unknown file type %d; not restored: %s\n"), attr->type, attr->fname); break; } return CF_ERROR; }
int main(void) { int fdsrv, bread; struct bunch msg; int i=0; int j=0; int ret; int wynik; int sem[4]; int def_val[] = {X1,X2,X3,X4}; if(mkfifo("fifo_server", S_IFIFO|0755) == -1) { perror("Tworzenie fifo_server"); exit(EXIT_FAILURE); } for(i=0; i<4; i++) if((sem[i] = semget(1111*(i+1), def_val[i], IPC_CREAT|0755)) == -1 ) { perror("Semafor create"); exit(EXIT_FAILURE); } for(i=0; i<4; i++) for(j=0; j<def_val[i]; j++) if(semctl(sem[i], j, SETVAL, i+1) == -1) { perror("Nadawanie wartosci sem"); exit(EXIT_FAILURE); } if((fdsrv = open("fifo_server", O_RDONLY)) == -1) { perror("Otwieranie kolejki fifo_server"); exit(EXIT_FAILURE); } while(1) { bread = read(fdsrv, &msg, sizeof(msg)); if(bread < 0) { perror("blad read in while(1)"); exit(EXIT_FAILURE); } if(bread > 0) { printf("Bunch %d\n",i++); printf("Message received from client %d\n", msg.id); printf("There is %d people who wants to eat\n", msg.size); sendResponse(msg, sem); for(i=1; i<4; i++) { for(j=0; j<def_val[i]; j++) { if( (ret = semctl(sem[i], j, GETVAL,0)) == -1) { perror("semctl\n"); exit(EXIT_FAILURE); } wynik = def_val[i] - ret; wynik = (wynik <0) ? 0 : wynik; printf("Stolik dla %d, zajete %d\n", i+1, wynik); } } } } return 0; }
int ConvertToMp3_o( CONVDATA *cn) { int pid,status; CONVDATA Cn; Cn= *cn; Ssec= cn->StartSec; Esec= cn->EndSec; if(!CheckMedia(cn->infile)){ return 0; } if(Esec < 0) { cn->EndSec = Minfo.TotSec +Esec; Esec= cn->EndSec; } if(Esec > Minfo.TotSec) { cn->EndSec = Minfo.TotSec ; Esec= cn->EndSec; } strcpy(GrabFileName,cn->outfile); if ((pid=fork())==0) { char command[500],Fifo[100],options[100]; sprintf(Fifo,"/tmp/Fifo%-d",getpid()); mkfifo(Fifo,0600); if ((pid=fork())==0) { options[0] ='\0'; if(fabs(cn->Enhfac-1.0)> 0.1) { switch(cn->VolEnh) { case 1: sprintf(options," --scale-l %lf ",cn->Enhfac); break; case 2: sprintf(options," --scale-r %lf ",cn->Enhfac); break; case 3: sprintf(options," --scale %lf ",cn->Enhfac); break; } } switch(cn->Quality) { case 1: strcat(options," -V0 -q 0 "); break; case 2: strcat(options," -V2 -q 2 "); break; case 3: strcat(options," -V4 -q 4 "); break; } sprintf(command,"kglame --quiet %-s %-s \"%-s\"",options,Fifo,Cn.outfile); // printf("%s\n",command); runfunction(command,NULL,kgLame); // fprintf(stderr,"Lame over\n"); exit(0); } else { options[0] ='\0'; if(cn->FullRange != 1) { int sh,sm,ss,smil,secs,eh,em,es,emil; float frac; secs = cn->StartSec; smil = (cn->StartSec - secs)*1000; ss = secs%60; secs = secs/60; sm = secs%60; sh = secs/60; if(cn->EndSec <=cn->StartSec ) cn->EndSec=0; secs = cn->EndSec-cn->StartSec; emil = (cn->EndSec-cn->StartSec -secs)*1000; es = secs%60; secs = secs/60; em = secs%60; eh = secs/60; if(cn->EndSec > 0) { sprintf(options," -ss %-d:%-d:%-d.%-d -endpos %-d:%-d:%-d.%-d", sh,sm,ss,smil,eh,em,es,emil); } else { sprintf(options," -ss %-d:%-d:%-d.%-d ", sh,sm,ss,smil); } } sprintf(command,"Mplayer -vo null -ao pcm:file=%-s %s \"%-s\"", Fifo,options,Cn.infile); // printf("%s\n",command); runfunction(command,ProcessMp3Conversion,Mplayer); // close(open(Fifo,O_RDONLY)); // fprintf(stderr,"Removing Fifo\n"); remove(Fifo); waitpid(pid,&status,0); } exit(0); } else { waitpid(pid,&status,0); } }
void init (int argc,char *argv[]) { struct lac *lac; struct in_addr listenaddr; struct utsname uts; init_args (argc,argv); srand( time(NULL) ); rand_source = 0; init_addr (); if (init_config ()) { l2tp_log (LOG_CRIT, "%s: Unable to load config file\n", __FUNCTION__); exit (1); } if (uname (&uts)<0) { l2tp_log (LOG_CRIT, "%s : Unable to determine host system\n", __FUNCTION__); exit (1); } init_tunnel_list (&tunnels); if (init_network ()) exit (1); if (gconfig.daemon) daemonize (); consider_pidfile(); signal (SIGTERM, &sigterm_handler); signal (SIGINT, &sigint_handler); signal (SIGCHLD, &sigchld_handler); signal (SIGUSR1, &sigusr1_handler); signal (SIGHUP, &sighup_handler); init_scheduler (); unlink(gconfig.controlfile); mkfifo (gconfig.controlfile, 0600); open_controlfd(); l2tp_log (LOG_INFO, "xl2tpd version " SERVER_VERSION " started on %s PID:%d\n", hostname, getpid ()); l2tp_log (LOG_INFO, "Written by Mark Spencer, Copyright (C) 1998, Adtran, Inc.\n"); l2tp_log (LOG_INFO, "Forked by Scott Balmos and David Stipp, (C) 2001\n"); l2tp_log (LOG_INFO, "Inherited by Jeff McAdams, (C) 2002\n"); l2tp_log (LOG_INFO, "Forked again by Xelerance (www.xelerance.com) (C) 2006\n"); listenaddr.s_addr = gconfig.listenaddr; l2tp_log (LOG_INFO, "Listening on IP address %s, port %d\n", inet_ntoa(listenaddr), gconfig.port); lac = laclist; while (lac) { if (lac->autodial) { #ifdef DEBUG_MAGIC l2tp_log (LOG_DEBUG, "%s: Autodialing '%s'\n", __FUNCTION__, lac->entname[0] ? lac->entname : "(unnamed)"); #endif lac->active = -1; switch_io = 1; /* If we're a LAC, autodials will be ICRQ's */ magic_lac_dial (lac); } lac = lac->next; } }
int main(int argc, char **argv) { int fd; int pty; int ret; char ptyName[80]; const char* ifnames[MAXFIFO]; const char* cfname = NULL; const char* ofname = NULL; const char* dfname = NULL; const char* debugfname = NULL; int numPrompts = 0; char *prompts[MAXPROMPTS]; int normalPrompt[MAXPROMPTS]; int fifos[MAXFIFO]; int numFifo=0; int dumpFd=-1; int outFd=-1; int controlFd=-1; int laxWaitForReadline=0; pamperReadline = 0; clearPendingOnInterrupt = 0; clearPending = 0; doStatusReport = 0; int doEcho = 1; int c; while ((c = getopt(argc, argv, "+i:o:c:d:D:r:R:e::l::z::")) != -1) { switch(c) { case 'i': if(numFifo >= MAXFIFO) { fprintf(stderr,"too many fifo\n"); exit(1); } ifnames[numFifo] = optarg; numFifo++; break; case 'o': ofname = optarg; break; case 'c': cfname = optarg; break; case 'd': dfname = optarg; break; case 'D': debugfname = optarg; break; case 'R': case 'r': if(numPrompts >= MAXPROMPTS) { fprintf(stderr,"too many prompts\n"); exit(1); } pamperReadline = 1; prompts[numPrompts] = optarg; if(c=='R') { normalPrompt[numPrompts] = 0; if(*prompts[numPrompts] == '\0') { write(2,"can't have empty string be non-normal prompt\n",45); normalPrompt[numPrompts] = 1; } } else { normalPrompt[numPrompts] = 1; } numPrompts++; break; case 'e': doEcho = 0; if(optarg) { doEcho = strtol(optarg,NULL,10); } break; case 'l': laxWaitForReadline = 0; if(optarg) { laxWaitForReadline = strtol(optarg,NULL,10); } break; case 'z': clearPendingOnInterrupt = 1; clearPending = 1; // to show that if(optarg) { clearPendingOnInterrupt = strtol(optarg,NULL,10); } break; } } if(pamperReadline && !clearPending) { clearPendingOnInterrupt = 1; // default with readline if not set explicitly clearPending = 0; } quit = 0; struct termios origTermData; tcgetattr(0,&origTermData); // openpty(&fd,&slave,NULL,&tt,&win); // fd = getpt(); // perhaps O_ASYNC is interesting fd = open("/dev/ptmx", O_RDWR|O_NOCTTY); if(fd == -1) { printf("error with getpt\n"); exit(1); } ret = grantpt(fd); if(ret != 0) { printf("error with grantpt\n"); exit(1); } ret = unlockpt(fd); if(ret != 0) { printf("error with unlockpt\n"); exit(1); } switch(childpid = fork()) { case -1: printf("ERROR!!!!\n"); exit(1); case 0: // printf("child\n"); ret = ptsname_r(fd,ptyName,80); if(ret != 0) { printf("ERROR: ptsname\n"); exit(1); } pty = open(ptyName,O_RDWR); if(pty == -1) { printf("ERROR: could not open '%s'\n",ptyName); exit(1); } if(doEcho) { tcsetattr(pty,TCSANOW,&origTermData); } else { struct termios termData; int setTerm=0; setTerm = 1; termData = origTermData; termData.c_lflag &= ~ECHO; tcsetattr(pty,TCSANOW,&termData); } if(pty == 0) { printf("ERROR: tcsetattr (in child)\n"); exit(1); } close(0); close(1); close(2); dup2(pty,0); dup2(pty,1); dup2(pty,2); setsid(); // connect the new process to the tty ret = ioctl(0, TIOCSCTTY, 0); if(ret == -1) { printf("error with ioctl\n"); fflush(stdout); exit(1); } close(fd); close(pty); // char program[80] = "echoAsterix"; // char arg1[80] = "--raw"; char program[80] = "R"; char arg1[80] = "--no-save"; // char program[80] = "bash"; // char arg1[80] = ""; char *execArgs[3]; execArgs[0] = program; execArgs[1] = arg1; execArgs[2] = (char*)NULL; // execArgs[1] = (char*)NULL; if(argc > optind) { execvp(argv[optind],&argv[optind]); } else { execvp(execArgs[0],execArgs); } // execlp("R", "--no-save", (char*)0); // execlp("matlab", "-nojvm", "-nosplash", "-nodesktop", (char*)0); printf("CHILD HAS AN ERROR...DIDN'T execlp"); exit(1); } // printf("parent\n"); // signal(SIGINT,SIG_IGN); signal(SIGCHLD,childDead); // signal(SIGUSR1,clearPamperReadline); // signal(SIGUSR2,setPamperReadline); signal(SIGINT,interruptHandler); signal(SIGUSR1,statusReportHandler); int i; struct stat statOfFile; int curFifo; for(curFifo=0;curFifo<numFifo;curFifo++) { ret = stat(ifnames[curFifo],&statOfFile); if(ret != 0) { if(errno == ENOENT) { // file does not exist, create it ret = mkfifo(ifnames[curFifo],S_IRWXU | S_IRWXG | S_IRWXO ); if(ret != 0) { perror(argv[0]); exit(1); } } else { perror(argv[0]); exit(1); } } else { if(!S_ISFIFO(statOfFile.st_mode)) { printf("'%s' is not a FIFO\n",ifnames[curFifo]); exit(1); } } fifos[curFifo] = open(ifnames[curFifo],O_RDWR); if(fifos[curFifo] == -1) { printf("error opening FIFO '%s'\n",ifnames[curFifo]); exit(1); } struct flock fl; fl.l_type = F_WRLCK; fl.l_whence = SEEK_SET; fl.l_start = 0; fl.l_len = 0; fl.l_pid = 0; if(fcntl(fifos[curFifo],F_SETLK,&fl) == -1) { fcntl(fifos[curFifo],F_GETLK,&fl); printf("fifo '%s' is locked by %d\n",ifnames[curFifo],fl.l_pid); close(fifos[curFifo]); exit(1); } } if(ofname) { outFd = open(ofname,O_WRONLY | O_CREAT | O_TRUNC,0644); if(outFd == -1) { printf("error opening file '%s'\n",ofname); exit(1); } } if(cfname) { // TODO make this a subroutine ret = stat(cfname,&statOfFile); if(ret != 0) { if(errno == ENOENT) { // file does not exist, create it ret = mkfifo(cfname,S_IRWXU | S_IRWXG | S_IRWXO ); if(ret != 0) { perror(argv[0]); exit(1); } } else { perror(argv[0]); exit(1); } } else { if(!S_ISFIFO(statOfFile.st_mode)) { printf("'%s' is not a FIFO\n",cfname); exit(1); } } controlFd = open(cfname,O_RDWR); if(controlFd == -1) { printf("error opening control file '%s'\n",cfname); exit(1); } struct flock fl; fl.l_type = F_WRLCK; fl.l_whence = SEEK_SET; fl.l_start = 0; fl.l_len = 0; fl.l_pid = 0; if(fcntl(controlFd,F_SETLK,&fl) == -1) { fcntl(controlFd,F_GETLK,&fl); printf("fifo '%s' is locked by %d\n",cfname,fl.l_pid); close(controlFd); exit(1); } } if(dfname) { dumpFd = open(dfname,O_WRONLY | O_CREAT | O_TRUNC,0644); if(dumpFd == -1) { printf("error opening file '%s'\n",dfname); exit(1); } } struct termios termData; int setTerm=0; setTerm = 1; termData = origTermData; // tcgetattr(0,&termData); cfmakeraw(&termData); // termData.c_iflag &= ~IGNBRK; if(clearPendingOnInterrupt) { // catch interrupts instead of passing them through the data stream. // We will interrupt child instead of letting the terminal do it. // This is usually undesirable since they can no longer control // interrupt behavior through their terminal. termData.c_lflag |= ISIG; } // termData.c_lflag &= ~ICANON; // termData.c_lflag &= ~ECHO; // termData.c_lflag |= ECHO; // local echo // termData.c_cc[VMIN] = 1; // termData.c_cc[VTIME] = 0; tcsetattr(0,TCSANOW,&termData); // if(argc>1 && strcmp(ifname,"--raw")==0) { // } // fcntl(fd,F_SETFL,O_NONBLOCK); fd_set readSet; fd_set writeSet; fd_set errorSet; int numBytes; int max; char toFdBuf[BUFSIZE]; char *toFdPos = toFdBuf; int toFdSize = 0; char toOutBuf[BUFSIZE]; char *toOutPos = toOutBuf; int toOutSize = 0; waitForReadline=0; char *posInPrompts[MAXPROMPTS]; int curPrompt; for(curPrompt=0;curPrompt<numPrompts;curPrompt++) { posInPrompts[curPrompt] = prompts[curPrompt]; } onNormalPrompt = 1; int debugfd=-1; if(debugfname) { debugfd = open(debugfname,O_WRONLY | O_CREAT | O_TRUNC,0644); if(debugfd == -1) { printf("error opening debug file '%s'",debugfname); exit(1); } } while(!quit) { FD_ZERO(&readSet); FD_ZERO(&writeSet); FD_ZERO(&errorSet); max = -1; FD_SET(0,&errorSet); max = (max>0)?max:0; FD_SET(1,&errorSet); max = (max>1)?max:1; for(curFifo=0;curFifo<numFifo;curFifo++) { FD_SET(fifos[curFifo],&errorSet); max = (max>fifos[curFifo])?max:fifos[curFifo]; } if(controlFd != -1) { FD_SET(controlFd,&errorSet); max = (max>controlFd)?max:controlFd; } FD_SET(fd,&errorSet); max = (max>fd)?max:fd; if(toFdSize < BUFSIZE) { FD_SET(0,&readSet); max = (max>0)?max:0; if(onNormalPrompt) { for(curFifo=0;curFifo<numFifo;curFifo++) { FD_SET(fifos[curFifo],&readSet); max = (max>fifos[curFifo])?max:fifos[curFifo]; } } } if(toOutSize < BUFSIZE) { FD_SET(fd,&readSet); max = (max>fd)?max:fd; } if(controlFd != -1) { FD_SET(controlFd,&readSet); max = (max>controlFd)?max:controlFd; } if(!waitForReadline && toFdSize > 0) { FD_SET(fd,&writeSet); max = (max>fd)?max:fd; } if(toOutSize > 0) { FD_SET(1,&writeSet); max = (max>1)?max:1; } // ret = select(max+1,&readSet,&writeSet,&errorSet,NULL); struct timeval tv; tv.tv_sec = 1; tv.tv_usec = 0; if(debugfd != -1) { char buf[1024]; int size; size = snprintf(buf,1024,"%d%d%d%d %d%d%d%d %d%d%d%d - ", FD_ISSET(0,&readSet),FD_ISSET(1,&readSet), FD_ISSET(numFifo>0?fifos[0]:0,&readSet), FD_ISSET(fd,&readSet), FD_ISSET(0,&writeSet),FD_ISSET(1,&writeSet), FD_ISSET(numFifo>0?fifos[0]:0,&writeSet), FD_ISSET(fd,&writeSet), FD_ISSET(0,&errorSet),FD_ISSET(1,&errorSet), FD_ISSET(numFifo>0?fifos[0]:0,&errorSet), FD_ISSET(fd,&errorSet)); write(debugfd,buf,size); } errno = 0; if(doStatusReport) { char buf[1024]; int size; size = snprintf(buf,1024,"before %d%d%d%d %d%d%d%d %d%d%d%d\r\n", FD_ISSET(0,&readSet),FD_ISSET(1,&readSet), FD_ISSET(numFifo>0?fifos[0]:0,&readSet), FD_ISSET(fd,&readSet), FD_ISSET(0,&writeSet),FD_ISSET(1,&writeSet), FD_ISSET(numFifo>0?fifos[0]:0,&writeSet), FD_ISSET(fd,&writeSet), FD_ISSET(0,&errorSet),FD_ISSET(1,&errorSet), FD_ISSET(numFifo>0?fifos[0]:0,&errorSet), FD_ISSET(fd,&errorSet)); write(1,buf,size); doStatusReport--; } ret = select(max+1,&readSet,&writeSet,&errorSet,&tv); if(doStatusReport) { char buf[1024]; int size; size = snprintf(buf,1024,"after %d%d%d%d %d%d%d%d %d%d%d%d\r\n", FD_ISSET(0,&readSet),FD_ISSET(1,&readSet), FD_ISSET(numFifo>0?fifos[0]:0,&readSet), FD_ISSET(fd,&readSet), FD_ISSET(0,&writeSet),FD_ISSET(1,&writeSet), FD_ISSET(numFifo>0?fifos[0]:0,&writeSet), FD_ISSET(fd,&writeSet), FD_ISSET(0,&errorSet),FD_ISSET(1,&errorSet), FD_ISSET(numFifo>0?fifos[0]:0,&errorSet), FD_ISSET(fd,&errorSet)); write(1,buf,size); } if(debugfd != -1) { char buf[1024]; int size; size = snprintf(buf,1024,"%d%d%d%d %d%d%d%d %d%d%d%d ", FD_ISSET(0,&readSet),FD_ISSET(1,&readSet), FD_ISSET(numFifo>0?fifos[0]:0,&readSet), FD_ISSET(fd,&readSet), FD_ISSET(0,&writeSet),FD_ISSET(1,&writeSet), FD_ISSET(numFifo>0?fifos[0]:0,&writeSet), FD_ISSET(fd,&writeSet), FD_ISSET(0,&errorSet),FD_ISSET(1,&errorSet), FD_ISSET(numFifo>0?fifos[0]:0,&errorSet), FD_ISSET(fd,&errorSet)); write(debugfd,buf,size); } if(ret == -1) { if(errno == EINTR) { if(doStatusReport) { write(1,"caught a signal\r\n",strlen("caught a signal\r\n")); } if(debugfd != -1) { char buf = '\n'; write(debugfd,&buf,1); } continue; } else { printf("select had an error\n"); break; } } if(clearPending) { toFdSize = 0; clearPending = 0; if(debugfd != -1) { char buf = '\n'; write(debugfd,&buf,1); } continue; } if(errno == EINTR) { write(1,"caught a signal with good return value\r\n", strlen("caught a signal with good return value\r\n")); if(debugfd != -1) { char buf = '\n'; write(debugfd,&buf,1); } continue; } if(ret == 0) { if(debugfd != -1) { char buf = '\n'; write(debugfd,&buf,1); } if(laxWaitForReadline) { waitForReadline = 0; } continue; } // check for errors if(FD_ISSET(0,&errorSet)) { error_at_line(0,errno,__FILE__,__LINE__,"0 is set in errorSet"); break; } if(FD_ISSET(1,&errorSet)) { error_at_line(0,errno,__FILE__,__LINE__,"1 is set in errorSet"); break; } for(curFifo=0;curFifo<numFifo;curFifo++) { if(FD_ISSET(fifos[curFifo],&errorSet)) { error_at_line(0,errno,__FILE__,__LINE__, "fifos[%d] is set in errorSet",curFifo); break; } } if(FD_ISSET(fd,&errorSet)) { error_at_line(0,errno,__FILE__,__LINE__,"fd is set in errorSet"); break; } if(controlFd != -1 && FD_ISSET(controlFd,&errorSet)) { error_at_line(0,errno,__FILE__,__LINE__,"controlFd is set in errorSet"); break; } if(controlFd != -1 && FD_ISSET(controlFd,&readSet)) { // TODO not interrupt safe int k; char command; write(2,"eet command ",12); numBytes = read(controlFd,&command,1); if(numBytes != 1) continue; write(2,&command,1); write(2," '",2); char *buf = malloc(CONTROL_MSG_SIZE); buf[CONTROL_MSG_SIZE] = '\0'; for(k=0;k<CONTROL_MSG_SIZE-1;k++) { numBytes = read(controlFd,&buf[k],1); if(numBytes != 1) { buf[k] = '\0'; break; } if(buf[k] == '\0') { break; } } write(2,buf,strlen(buf)); write(2,"'",1); if(numBytes != 1 || k >= CONTROL_MSG_SIZE-1) { write(2,"improperly terminated",21); } write(2,"\r\n",2); switch(command) { case 'R': case 'r': if(numPrompts >= MAXPROMPTS) { fprintf(stderr,"too many prompts\n"); exit(1); } pamperReadline = 1; prompts[numPrompts] = buf; if(command=='R') { normalPrompt[numPrompts] = 0; if(*prompts[numPrompts] == '\0') { write(2,"can't have empty string be non-normal prompt\n",45); normalPrompt[numPrompts] = 1; } } else { normalPrompt[numPrompts] = 1; } posInPrompts[numPrompts] = prompts[numPrompts]; numPrompts++; waitForReadline = 0; break; case '*': waitForReadline = 0; break; case 'p': waitForReadline = 0; pamperReadline = 0; if(buf && buf[0] != '\0') { pamperReadline = strtol(buf,NULL,10); } onNormalPrompt = 1; break; case 'l': laxWaitForReadline = 0; if(buf && buf[0] != '\0') { laxWaitForReadline = strtol(buf,NULL,10); } break; case 'z': clearPendingOnInterrupt = 1; if(buf) { clearPendingOnInterrupt = strtol(buf,NULL,10); } break; } continue; } int numBytes0=0,numBytes1=0,numBytesFifo=0, numBytesFdIn=0,numBytesFdOut=0; // write to these if(FD_ISSET(1,&writeSet)) { int numToWrite; if(toOutPos-toOutBuf+toOutSize < BUFSIZE) { numToWrite = toOutSize; } else { numToWrite = BUFSIZE - (toOutPos-toOutBuf); } numBytes = write(1,toOutPos,numToWrite); if(numBytes == -1) { error_at_line(0,errno,__FILE__,__LINE__,"write failed");continue; } if(outFd != -1) { // everything going to stdout also goes to outFd write(outFd,toOutPos,numBytes); // hope no error (don't reuse numBytes) } toOutSize -= numBytes; toOutPos += numBytes; if(toOutPos - toOutBuf >= BUFSIZE) { toOutPos -= BUFSIZE; } // printf("write to stdout %d bytes\r\nbase 0x%tx\r\n" // "pos 0x%tx toOutSize is now %d numToWrite %d\r\n", // numBytes, (ptrdiff_t)toOutBuf, // (ptrdiff_t)toOutPos,toOutSize,numToWrite); numBytes1 = numBytes; } if(FD_ISSET(fd,&writeSet)) { int numToWrite; if(toFdPos-toFdBuf+toFdSize < BUFSIZE) { numToWrite = toFdSize; } else { numToWrite = BUFSIZE - (toFdPos-toFdBuf); } if(pamperReadline) { int i; char *tmp=toFdPos; for(i=0;i<numToWrite;i++) { if(*tmp == '\r' || *tmp == '\n') { numToWrite = i+1; // write(1,"newline",strlen("newline")); waitForReadline = 1; break; } tmp++; if(tmp - toFdBuf >= BUFSIZE) { // not technically needed (range of numToWrite will not cross this) tmp -= BUFSIZE; } } } if(clearPending) { toFdSize = 0; clearPending = 0; if(debugfd != -1) { char buf = '\n'; write(debugfd,&buf,1); } continue; } numBytes = write(fd,toFdPos,numToWrite); if(pamperReadline && numBytes != numToWrite) { waitForReadline = 0; // write(1,"unsetting waitForReadline",strlen("unsetting waitForReadline")); } if(numBytes == -1) { error_at_line(0,errno,__FILE__,__LINE__,"write failed");continue; } if(dumpFd != -1) { // duplicate traffic to terminal program in dumpFd write(dumpFd,toFdPos,numBytes); // hope no error (don't reuse numBytes) } toFdSize -= numBytes; toFdPos += numBytes; if(toFdPos - toFdBuf >= BUFSIZE) { toFdPos -= BUFSIZE; } // printf("write to fd %d bytes\r\nbase 0x%tx\r\n" // "pos 0x%tx toFdSize is now %d numToWrite %d\r\n", // numBytes, (ptrdiff_t)toFdBuf, // (ptrdiff_t)toFdPos,toFdSize,numToWrite); numBytesFdIn = numBytes; } // read from these if(FD_ISSET(0,&readSet)) { int numToRead; char *startPos; if(toFdPos-toFdBuf+toFdSize < BUFSIZE) { startPos = toFdPos+toFdSize; numToRead = BUFSIZE - (startPos - toFdBuf); } else { startPos = toFdPos+toFdSize-BUFSIZE; numToRead = BUFSIZE - toFdSize; } numBytes = read(0,startPos,numToRead); if(numBytes == -1) { error_at_line(0,errno,__FILE__,__LINE__,"read failed");continue; } toFdSize += numBytes; // printf("read from stdin %d bytes\r\nat 0x%tx\r\nbase 0x%tx\r\n" // "pos 0x%tx toFdSize is now %d numToRead %d\r\n", // numBytes,(ptrdiff_t)startPos, (ptrdiff_t)toFdBuf, // (ptrdiff_t)toFdPos,toFdSize,numToRead); numBytes0 = numBytes; } for(curFifo=0;curFifo<numFifo;curFifo++) { if(FD_ISSET(fifos[curFifo],&readSet)) { int numToRead; char *startPos; if(toFdPos-toFdBuf+toFdSize < BUFSIZE) { startPos = toFdPos+toFdSize; numToRead = BUFSIZE - (startPos - toFdBuf); } else { startPos = toFdPos+toFdSize-BUFSIZE; numToRead = BUFSIZE - toFdSize; } numBytes = read(fifos[curFifo],startPos,numToRead); if(numBytes == -1) { error_at_line(0,errno,__FILE__,__LINE__,"read failed");continue; } toFdSize += numBytes; // printf("read from fifos[%d] %d bytes\r\nat 0x%tx\r\nbase 0x%tx\r\n" // "pos 0x%tx toFdSize is now %d numToRead %d\r\n",curFifo, // numBytes,(ptrdiff_t)startPos, (ptrdiff_t)toFdBuf, // (ptrdiff_t)toFdPos,toFdSize,numToRead); numBytesFifo += numBytes; } } if(FD_ISSET(fd,&readSet)) { int numToRead; char *startPos; if(toOutPos-toOutBuf+toOutSize < BUFSIZE) { startPos = toOutPos+toOutSize; numToRead = BUFSIZE - (startPos - toOutBuf); } else { startPos = toOutPos+toOutSize-BUFSIZE; numToRead = BUFSIZE - toOutSize; } numBytes = read(fd,startPos,numToRead); if(pamperReadline && (waitForReadline || !onNormalPrompt)) { // need to look all the time when on a non-normal prompt since // we may not input a newline on a non-normal prompt and have // it transition to a normal prompt (think q given to less) int i; int curPrompt; for(curPrompt=0;curPrompt<numPrompts;curPrompt++) { if(*prompts[curPrompt] != '\0') { for(i=0;i<numBytes;i++) { if(*posInPrompts[curPrompt] == '\0') { posInPrompts[curPrompt] = prompts[curPrompt]; } if(*posInPrompts[curPrompt] == startPos[i]) { posInPrompts[curPrompt]++; } else { posInPrompts[curPrompt] = prompts[curPrompt]; } } } } int checkForMore = 0; int normal = 1; for(curPrompt=0;curPrompt<numPrompts;curPrompt++) { if(*posInPrompts[curPrompt] == '\0') { checkForMore = 1; normal = normal && normalPrompt[curPrompt]; } } if(checkForMore || numPrompts <= 0) { // TODO this should really be rolled into the select in the main // loop so we can do other things instead of waiting in a sleep struct timespec ts; ts.tv_sec = 0; // ts.tv_nsec = 10000000; // 10ms ts.tv_nsec = 1000000; // 1ms // write(1,"waiting",strlen("waiting")); nanosleep(&ts,NULL); FD_ZERO(&readSet); FD_SET(fd,&readSet); tv.tv_sec = 0; tv.tv_usec = 0; ret = select(fd+1,&readSet,NULL,NULL,&tv); if(!FD_ISSET(fd,&readSet)) { // no more input available (on prompt) waitForReadline = 0; onNormalPrompt = normal; // if(onNormalPrompt) { // write(2,"normalPrompt",strlen("normalPrompt")); // } else { // write(2,"notNormalPrompt",strlen("notNormalPrompt")); // } } } } // if(numBytes == -1) {error_at_line(0,errno,__FILE__,__LINE__,"read failed");continue; } if(numBytes == -1) {break;} // usually pipe breaks before SIGCHLD toOutSize += numBytes; // printf("read from fd %d bytes\r\nat 0x%tx\r\nbase 0x%tx\r\n" // "pos 0x%tx toOutSize is now %d numToRead %d\r\n", // numBytes,(ptrdiff_t)startPos, (ptrdiff_t)toOutBuf, // (ptrdiff_t)toOutPos,toOutSize,numToRead); numBytesFdOut = numBytes; } if(debugfd != -1) { // TODO do the fifos right in the dump (instead of only first one) char buf[1024]; int size; size = snprintf(buf,1024, "fd%5d out%5d numBytes x:%d %d:x x:%d %d:%d\r\n", toFdSize,toOutSize, numBytes0,numBytes1,numBytesFifo, numBytesFdIn,numBytesFdOut); write(debugfd,buf,size); } } if(debugfd != -1) { close(debugfd); } close(fd); for(curFifo=0;curFifo<numFifo;curFifo++) { close(fifos[curFifo]); } if(outFd != -1) { close(outFd); } if(dumpFd != -1) { close(dumpFd); } if(setTerm) { tcsetattr(0,TCSANOW,&origTermData); } }
/** Reads the command received and excecutes the corrisponding process sending it it's arguments and also responds to special characters.*/ int process_input(const char * input, int tty_number) { int piped = 0; char file_call_buffer[1024]; char stdout_call_buffer[128]; char stdin_call_buffer[128]; int stdout_file = 0; int stdin_file = 0; int read_ptr = 0; int stdin = 0; int stdout = 0; do { int i = 0; int write_i = 0; for(; i < 128; ++i) { stdout_call_buffer[i] = 0; stdin_call_buffer[i] = 0; } for(i = 0; i < 1024; ++i) { file_call_buffer[i] = 0; } i = read_ptr; char * file_call; int valid_input = 0; char * current_buffer = file_call_buffer; for(; input[i] && input[i] != '|'; ++i) { if(strlen(current_buffer) > 0 ) { if(input[i] == '>') { current_buffer = stdout_call_buffer; valid_input = 0; write_i = 0; stdout_file = 1; continue; } else if (input[i] == '<') { current_buffer = stdin_call_buffer; valid_input = 0; write_i = 0; stdin_file = 1; continue; } } else { if (input[i] == '>' || input[i] == '<') { return 0; } } valid_input = input[i] != ' '; if(!(write_i == 0 && !valid_input)) { current_buffer[write_i++] = input[i]; } } if(i == 0 && input[i] == '|') { return 0; } piped = (input[i] == '|') && !stdin_file && !stdout_file; i++; if(piped) { read_ptr = i; } int n = 0; char** strs = split_string(file_call_buffer, ' ', &n); int pid = pcreate(strs[0], n, strs); if(pid != -1) { if(stdout_file) { int _stdout = open(stdout_call_buffer, O_WR | O_NEW); if(_stdout >= 0) { pdup2(pid, _stdout, STDOUT); } else { printf("TTY: file %s could not be opened for output, invalid perms?\n", stdout_call_buffer); } } if(stdin_file) { int _stdin = open(stdin_call_buffer, O_RD); if(_stdin >= 0) { pdup2(pid, _stdin, STDIN); } else { printf("TTY: file %s could not be opened for input, invalid perms?\n", stdin_call_buffer); } } // For pipe if(stdin) { pdup2(pid, stdin, STDIN); } char cad[20]; if(piped) { cad[0] = '.'; itoa(pid, cad + 1); stdout = mkfifo(cad, 0600); pdup2(pid,stdout,STDOUT); stdin = stdout; stdout = 0; } prun(pid); if(!string_ends_with(file_call_buffer, '&') && !piped) { waitpid(pid); rm(cad); } } } while(piped); return 1; }
int writeFIFO(int in) { const char *fifo_name = "/tmp/my_fifo"; int pipe_fd = -1; int data_fd = -1; int res = 0; const int open_mode = O_WRONLY; int bytes_sent = 0; char buffer[PIPE_BUF + 1]; int bytes_read = 0; if(access(fifo_name, F_OK) == -1) { printf ("Create the fifo pipe.\n"); res = mkfifo(fifo_name, 0777); if(res != 0) { fprintf(stderr, "Could not create fifo %s\n", fifo_name); exit(EXIT_FAILURE); } } if(in != -1) { std::ofstream file; file.open("Data.txt"); file<<in; file.close(); } printf("Process %d opening FIFO O_WRONLY\n", getpid()); pipe_fd = open(fifo_name, open_mode); printf("Process %d result %d\n", getpid(), pipe_fd); if(pipe_fd != -1) { bytes_read = 0; data_fd = open("Data.txt", O_RDONLY); if (data_fd == -1) { close(pipe_fd); fprintf (stderr, "Open file[Data.txt] failed\n"); return -1; } bytes_read = read(data_fd, buffer, PIPE_BUF); buffer[bytes_read] = '\0'; while(bytes_read > 0) { res = write(pipe_fd, buffer, bytes_read); if(res == -1) { fprintf(stderr, "Write error on pipe\n"); exit(EXIT_FAILURE); } bytes_sent += res; bytes_read = read(data_fd, buffer, PIPE_BUF); buffer[bytes_read] = '\0'; } close(pipe_fd); close(data_fd); } else exit(EXIT_FAILURE); printf("Process %d finished\n", getpid()); return 1; }
bool create_pipe(char* path) { if (mkfifo(path,0666) != 0) { if (errno != EEXIST) return false; } return true; }
int main(int argc, char *argv[]) { const char *code = argv[1]; const char *slash = strrchr(code, '/'); int ret; /* stupid automake! */ if (slash) code = slash + 1; if (code[0] == '_') { struct stat st; if (lstat(INPUT_FILE, &st)) return 77; switch (code[1]) { case T_BROKEN_SYMLINK: ex_linkdest[0]++; } } else { /* XXX: replace tests */ unlink(INPUT_FILE); unlink(OUTPUT_FILE); switch (code[0]) { case T_REGULAR: case T_EMPTY: if (!create_input(INPUT_FILE, code[0] == T_REGULAR)) { perror("Input creation failed"); return 2; } break; case T_BROKEN_SYMLINK: ex_linkdest[0]++; case T_SYMLINK: if (symlink(ex_linkdest, INPUT_FILE)) { perror("Input symlink creation failed"); return 77; } break; case T_NAMED_PIPE: if (mkfifo(INPUT_FILE, 0700)) { perror("Named pipe creation failed"); return 77; } break; case T_BLK_DEV: #ifdef S_IFBLK if (mknod(INPUT_FILE, 0700 | S_IFBLK, 0xff00)) { perror("Block device creation failed"); return 77; } #else fprintf(stderr, "Block devices not supported\n"); return 77; #endif break; case T_CHR_DEV: #ifdef S_IFCHR if (mknod(INPUT_FILE, 0700 | S_IFCHR, 0x0103)) { perror("Character device creation failed"); return 77; } #else fprintf(stderr, "Character devices not supported\n"); return 77; #endif break; default: fprintf(stderr, "Invalid arg: [%s]\n", code); return 3; } } ret = ai_cp_a(INPUT_FILE, OUTPUT_FILE); if (ret) { fprintf(stderr, "[%s] Copying failed: %s\n", code, strerror(errno)); return 1; } return compare_files(INPUT_FILE, OUTPUT_FILE, code); }
/** * Initialization of data structures for running under a debugger * using an extended MPICH/TotalView parallel debugger interface. Before the * spawn we need to check if we are being run under a TotalView-like * debugger; if so then inform applications via an MCA parameter. */ void init_before_spawn(orte_job_t *jdata) { char *env_name; orte_app_context_t *app; int i; int32_t ljob; char *attach_fifo; if (!MPIR_being_debugged && !orte_in_parallel_debugger) { /* if we were given a test debugger, then we still want to * colaunch it */ if (NULL != orte_debugger_base.test_daemon) { opal_output_verbose(2, orte_debugger_base.output, "%s No debugger test daemon specified", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME)); goto launchit; } /* if we were given an auto-detect rate, then we want to setup * an event so we periodically do the check */ if (0 < orte_debugger_mpirx_check_rate) { opal_output_verbose(2, orte_debugger_base.output, "%s Setting debugger attach check rate for %d seconds", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), orte_debugger_mpirx_check_rate); ORTE_TIMER_EVENT(orte_debugger_mpirx_check_rate, 0, attach_debugger); } else { /* create the attachment FIFO and put it into MPIR, setup readevent */ /* create a FIFO name in the session dir */ attach_fifo = opal_os_path(false, orte_process_info.job_session_dir, "debugger_attach_fifo", NULL); if ((mkfifo(attach_fifo, FILE_MODE) < 0) && errno != EEXIST) { opal_output(0, "CANNOT CREATE FIFO %s: errno %d", attach_fifo, errno); free(attach_fifo); return; } strncpy(MPIR_attach_fifo, attach_fifo, MPIR_MAX_PATH_LENGTH - 1); free (attach_fifo); open_fifo (); } return; } launchit: opal_output_verbose(2, orte_debugger_base.output, "%s: Spawned by a debugger", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME)); /* tell the procs they are being debugged */ env_name = mca_base_param_environ_variable("orte", "in_parallel_debugger", NULL); for (i=0; i < jdata->apps->size; i++) { if (NULL == (app = (orte_app_context_t*)opal_pointer_array_get_item(jdata->apps, i))) { continue; } opal_setenv(env_name, "1", true, &app->env); } free(env_name); /* check if we need to co-spawn the debugger daemons */ if ('\0' != MPIR_executable_path[0] || NULL != orte_debugger_base.test_daemon) { /* can only have one debugger */ if (NULL != orte_debugger_daemon) { opal_output(0, "-------------------------------------------\n" "Only one debugger can be used on a job.\n" "-------------------------------------------\n"); ORTE_UPDATE_EXIT_STATUS(ORTE_ERROR_DEFAULT_EXIT_CODE); return; } opal_output_verbose(2, orte_debugger_base.output, "%s Cospawning debugger daemons %s", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), (NULL == orte_debugger_base.test_daemon) ? MPIR_executable_path : orte_debugger_base.test_daemon); /* add debugger info to launch message */ orte_debugger_daemon = OBJ_NEW(orte_job_t); /* create a jobid for these daemons - this is done solely * to avoid confusing the rest of the system's bookkeeping */ orte_plm_base_create_jobid(orte_debugger_daemon); /* flag the job as being debugger daemons */ orte_debugger_daemon->controls |= ORTE_JOB_CONTROL_DEBUGGER_DAEMON; /* unless directed, we do not forward output */ if (!MPIR_forward_output) { orte_debugger_daemon->controls &= ~ORTE_JOB_CONTROL_FORWARD_OUTPUT; } /* add it to the global job pool */ ljob = ORTE_LOCAL_JOBID(orte_debugger_daemon->jobid); opal_pointer_array_set_item(orte_job_data, ljob, orte_debugger_daemon); /* create an app_context for the debugger daemon */ app = OBJ_NEW(orte_app_context_t); if (NULL != orte_debugger_base.test_daemon) { app->app = strdup(orte_debugger_base.test_daemon); } else { app->app = strdup((char*)MPIR_executable_path); } opal_argv_append_nosize(&app->argv, app->app); build_debugger_args(app); opal_pointer_array_add(orte_debugger_daemon->apps, app); orte_debugger_daemon->num_apps = 1; } return; }
int main(){ //создаем именованные каналы в ядре с местом в файловом пространстве имен printf("Создаю именованные каналы...");fflush(stdout); const char *pipe_in="in.fifo", *pipe_out="out.fifo"; unlink(pipe_in); unlink(pipe_out); int res=mkfifo(pipe_in,0666); if(-1==res){ perror("Ошибка создания канала in"); return 1; } res=mkfifo(pipe_out,0666); if(-1==res){ perror("Ошибка создания канала out"); return 2; } printf("ok!\n"); //получаем файловые дескрипторы каналов и переводим в неблокирующий режим (чтение и запись, чтоб не блокировалось здесь же сразу) printf("Получаю файловые дескрипторы..."); int fd_in=open(pipe_in,O_RDWR|O_NONBLOCK); if(-1==fd_in){ perror("Не получен дескриптор in"); return 3; } int fd_out=open(pipe_out,O_RDWR|O_NONBLOCK); if(-1==fd_out){ perror("Не получен дескриптор out"); close(fd_in); return 4; } printf("ok!\n"); //мультиплексирование printf("Мультиплексирование (select):\n"); fd_set set_for_read, set_for_write; //ровно по 1024 бит printf("Цикл:\n"); //узнаем наибольший номер дескриптора, чтоб узнать сколько битов в наборе нужно отслеживать int max=fd_in<fd_out ? fd_out : fd_in; //буфер на сервере (на случай задержки отправки) struct Buf *root=NULL, *tail=NULL; int is_out=0; //запускаем цикл проверки long long cnt=0; while(1){ //инициализация FD_ZERO(&set_for_read); FD_ZERO(&set_for_write); //добавляем в набор отслеживаемый на чтение дескриптор printf("\tдобавляем in..."); FD_SET(fd_in,&set_for_read); printf("ok!\n"); if(is_out){ printf("\tдобавляем out..."); FD_SET(fd_out,&set_for_write); printf("ok!\n"); } fflush(stdout); //запускаем проверку готовности ++cnt; printf("\n%lld)-->select...",cnt);fflush(stdout); select(max+1,&set_for_read,&set_for_write,NULL,NULL);//эта команда сбрасывает не готовые биты поля, поэтому нужно регистрировать поновой printf("ok!\n"); //проснулись if(FD_ISSET(fd_out,&set_for_write)){ //проверка готовности писать printf("-->write..."); if(root==NULL) FD_CLR(fd_out,&set_for_write);//снимаем с регистрации, т.к. нечего писать else{ int len=write(fd_out,root->data,root->len); if(len!=-1){//успешно записано printf("ok!\n"); struct Buf * tmp=root->next; free(root); root=tmp; if(root==NULL){ //все записано tail=NULL; is_out=0; } } } } if(FD_ISSET(fd_in,&set_for_read)){ //проверка готовности чтения printf("-->read..."); //читаем из канала char data[LEN+1]; int len=read(fd_in,data,LEN); if(-1!=len){ if(root==NULL) tail=root=(struct Buf*)malloc(sizeof(struct Buf)); else{ tail->next=(struct Buf*)malloc(sizeof(struct Buf)); tail=tail->next; } tail->next=NULL; tail->len=len; memcpy(tail->data,data,len); data[len]='\0'; printf("ok! data=%s\n",data); //регистрируем дескриптор out is_out=1; } } } //закрываем дескрипторы close(fd_in); close(fd_out); //выносим каналы из фалового пространства unlink(pipe_in); unlink(pipe_out); return 0; }
int main(int argc, char* argv[]) { char c; int i; time(&timer);//系统开始的时间 initFile(); if (!(ptr_auxMem = fopen(AUXILIARY_MEMORY, "r+"))) { do_error(ERROR_FILE_OPEN_FAILED); exit(1); } do_init(); do_print_info(); ptr_memAccReq = (Ptr_MemoryAccessRequest) malloc(sizeof(MemoryAccessRequest)); ///////////////////////////在main中创建管道 struct stat statbuf; int fifo; if(stat("/tmp/vmm",&statbuf)==0) { /* 如果FIFO文件存在,删掉 */ if(remove("/tmp/vmm")<0) { perror("remove failed"); exit(1); } } if(mkfifo("/tmp/vmm",0666)<0) { perror("mkfifo failed"); exit(1); } if((fifo=open("/tmp/vmm",O_RDONLY))<0) { perror("open failed"); exit(1); } /* 在循环中模拟访存请求与处理过程 */ while (TRUE) { //do_request(); if((read(fifo,ptr_memAccReq,sizeof(MemoryAccessRequest)))<0) { perror("read failed"); exit(1); }//读管道内容 do_response(); ///////// time(&timerc); if((timerc-timer)>=Time)//经过一定时间,更新页面老化算法的计数器 { for(i = 0; i < PAGE_SUM; i++) { pageTable[i].count_1=(pageTable[i].count_1>>1)|(pageTable[i].R<<31); pageTable[i].R=0; } timer=timerc; } printf("按1打印页表,按2打印页表和实存内容,按3打印页表、辅存和实存内容,按其他键不打印...\n"); if ((c = getchar()) == '1') do_print_info(); if (c== '2') { do_print_info(); do_print_actMem(); } if (c== '3') { do_print_info(); do_print_actMem(); do_print_auxMem(); } while (c != '\n') c = getchar(); printf("按X退出程序,按其他键继续...\n"); if ((c = getchar()) == 'x' || c == 'X') break; while (c != '\n') c = getchar(); //sleep(5000); } if (fclose(ptr_auxMem) == EOF) { do_error(ERROR_FILE_CLOSE_FAILED); exit(1); } close(fifo); return (0); }
int main_mknod(rtems_shell_mknod_globals* globals, int argc, char **argv) { char *name, *p; mode_t mode; portdev_t dev; pack_t *pack; u_long numbers[MAXARGS]; int n, ch, fifo, hasformat; int r_flag = 0; /* force: delete existing entry */ #ifdef KERN_DRIVERS int l_flag = 0; /* list device names and numbers */ int major; #endif #if RTEMS_REMOVED void *modes = 0; #endif uid_t uid = -1; gid_t gid = -1; int rval; struct getopt_data getopt_reent; memset(&getopt_reent, 0, sizeof(getopt_data)); dev = 0; fifo = hasformat = 0; pack = pack_native; #ifdef KERN_DRIVERS while ((ch = getopt(argc, argv, "lrRF:g:m:u:")) != -1) { #else while ((ch = getopt_r(argc, argv, "rRF:g:m:u:", &getopt_reent)) != -1) { #endif switch (ch) { #ifdef KERN_DRIVERS case 'l': l_flag = 1; break; #endif case 'r': r_flag = 1; break; case 'R': r_flag = 2; break; case 'F': pack = pack_find(getopt_reent.optarg); if (pack == NULL) errx(exit_jump, 1, "invalid format: %s", getopt_reent.optarg); hasformat++; break; case 'g': if (getopt_reent.optarg[0] == '#') { gid = strtol(getopt_reent.optarg + 1, &p, 10); if (*p == 0) break; } if (gid_name(getopt_reent.optarg, &gid) == 0) break; gid = strtol(getopt_reent.optarg, &p, 10); if (*p == 0) break; errx(exit_jump, 1, "%s: invalid group name", getopt_reent.optarg); case 'm': #if RTEMS_REMOVED modes = setmode(getopt_reent.optarg); if (modes == NULL) #endif err(exit_jump, 1, "Cannot set file mode `%s'", getopt_reent.optarg); break; case 'u': if (getopt_reent.optarg[0] == '#') { uid = strtol(getopt_reent.optarg + 1, &p, 10); if (*p == 0) break; } #if RTEMS_REMOVED if (uid_from_user(getopt_reent.optarg, &uid) == 0) break; #endif uid = strtol(getopt_reent.optarg, &p, 10); if (*p == 0) break; errx(exit_jump, 1, "%s: invalid user name", getopt_reent.optarg); default: case '?': usage(globals); } } argc -= getopt_reent.optind; argv += getopt_reent.optind; #ifdef KERN_DRIVERS if (l_flag) { print_device_info(argv); return 0; } #endif if (argc < 2 || argc > 10) usage(globals); name = *argv; argc--; argv++; umask(mode = umask(0)); mode = (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH) & ~mode; if (argv[0][1] != '\0') goto badtype; switch (*argv[0]) { case 'c': mode |= S_IFCHR; break; case 'b': mode |= S_IFBLK; break; case 'p': if (hasformat) errx(exit_jump, 1, "format is meaningless for fifos"); mode |= S_IFIFO; fifo = 1; break; default: badtype: errx(exit_jump, 1, "node type must be 'b', 'c' or 'p'."); } argc--; argv++; if (fifo) { if (argc != 0) usage(globals); } else { if (argc < 1 || argc > MAXARGS) usage(globals); } for (n = 0; n < argc; n++) { errno = 0; numbers[n] = strtoul(argv[n], &p, 0); if (*p == 0 && errno == 0) continue; #ifdef KERN_DRIVERS if (n == 0) { major = major_from_name(argv[0], mode); if (major != -1) { numbers[0] = major; continue; } if (!isdigit(*(unsigned char *)argv[0])) errx(1, "unknown driver: %s", argv[0]); } #endif errx(exit_jump, 1, "invalid number: %s", argv[n]); } switch (argc) { case 0: dev = 0; break; case 1: dev = numbers[0]; break; default: dev = callPack(globals, pack, argc, numbers); break; } #if RTEMS_REMOVED if (modes != NULL) mode = getmode(modes, mode); #endif umask(0); rval = fifo ? mkfifo(name, mode) : mknod(name, mode, dev); if (rval < 0 && errno == EEXIST && r_flag) { struct stat sb; if (lstat(name, &sb) != 0 || (!fifo && sb.st_rdev != dev)) sb.st_mode = 0; if ((sb.st_mode & S_IFMT) == (mode & S_IFMT)) { if (r_flag == 1) /* Ignore permissions and user/group */ return 0; if (sb.st_mode != mode) rval = chmod(name, mode); else rval = 0; } else { unlink(name); rval = fifo ? mkfifo(name, mode) : mknod(name, mode, dev); } } if (rval < 0) err(exit_jump, 1, "%s", name); if ((uid != (uid_t)-1 || gid != (uid_t)-1) && chown(name, uid, gid) == -1) /* XXX Should we unlink the files here? */ warn("%s: uid/gid not changed", name); return 0; } static void usage(rtems_shell_mknod_globals* globals) { const char *progname = getprogname(); (void)fprintf(stderr, "usage: %s [-rR] [-F format] [-m mode] [-u user] [-g group]\n", progname); (void)fprintf(stderr, #ifdef KERN_DRIVERS " [ name [b | c] [major | driver] minor\n" #else " [ name [b | c] major minor\n" #endif " | name [b | c] major unit subunit\n" " | name [b | c] number\n" " | name p ]\n"); #ifdef KERN_DRIVERS (void)fprintf(stderr, " %s -l [driver] ...\n", progname); #endif exit(1); } static int gid_name(const char *name, gid_t *gid) { struct group *g; g = getgrnam(name); if (!g) return -1; *gid = g->gr_gid; return 0; } static portdev_t callPack(rtems_shell_mknod_globals* globals, pack_t *f, int n, u_long *numbers) { portdev_t d; const char *error = NULL; d = (*f)(n, numbers, &error); if (error != NULL) errx(exit_jump, 1, "%s", error); return d; }
static int do_test (void) { int ret = 0; static const char *fifo_name = "some-fifo"; size_t filenamelen = strlen (dirbuf) + strlen (fifo_name) + 2; char *filename = xmalloc (filenamelen); snprintf (filename, filenamelen, "%s/%s", dirbuf, fifo_name); /* Create a fifo in the directory. */ int e = mkfifo (filename, 0777); if (e == -1) { printf ("fifo creation failed (%s)\n", strerror (errno)); ret = 1; goto out_nofifo; } long dir_pathconf = pathconf (dirbuf, _PC_PIPE_BUF); if (dir_pathconf < 0) { printf ("pathconf on directory failed: %s\n", strerror (errno)); ret = 1; goto out_nofifo; } long fifo_pathconf = pathconf (filename, _PC_PIPE_BUF); if (fifo_pathconf < 0) { printf ("pathconf on file failed: %s\n", strerror (errno)); ret = 1; goto out_nofifo; } int fifo = open (filename, O_RDONLY | O_NONBLOCK); if (fifo < 0) { printf ("fifo open failed (%s)\n", strerror (errno)); ret = 1; goto out_nofifo; } long dir_fpathconf = fpathconf (dir_fd, _PC_PIPE_BUF); if (dir_fpathconf < 0) { printf ("fpathconf on directory failed: %s\n", strerror (errno)); ret = 1; goto out; } long fifo_fpathconf = fpathconf (fifo, _PC_PIPE_BUF); if (fifo_fpathconf < 0) { printf ("fpathconf on file failed: %s\n", strerror (errno)); ret = 1; goto out; } if (fifo_pathconf != fifo_fpathconf) { printf ("fifo pathconf (%ld) != fifo fpathconf (%ld)\n", fifo_pathconf, fifo_fpathconf); ret = 1; goto out; } if (dir_pathconf != fifo_pathconf) { printf ("directory pathconf (%ld) != fifo pathconf (%ld)\n", dir_pathconf, fifo_pathconf); ret = 1; goto out; } if (dir_fpathconf != fifo_fpathconf) { printf ("directory fpathconf (%ld) != fifo fpathconf (%ld)\n", dir_fpathconf, fifo_fpathconf); ret = 1; goto out; } out: close (fifo); out_nofifo: close (dir_fd); if (unlink (filename) != 0) { printf ("Could not remove fifo (%s)\n", strerror (errno)); ret = 1; } return ret; }
int main(int argc, char *argv[]) { static struct option long_opts[] = { {"help", 0, NULL, 'h'}, {0,0,0,0} }; int opt, opti; while ((opt=getopt_long(argc,argv,"h",long_opts,&opti))!=-1) { switch (opt) { default: case 'h': usage(); exit(0); break; } } prctl(PR_SET_PDEATHSIG,SIGTERM); /* Ensure that if parent (the manager) dies, to kill this child too. */ /* Create FIFO */ int rv = mkfifo(vegas_DAQ_CONTROL, 0666); if (rv!=0 && errno!=EEXIST) { fprintf(stderr, "vegas_daq_server: Error creating control fifo\n"); perror("mkfifo"); exit(1); } /* Open command FIFO for read */ #define MAX_CMD_LEN 1024 char cmd[MAX_CMD_LEN]; int command_fifo; command_fifo = open(vegas_DAQ_CONTROL, O_RDONLY | O_NONBLOCK); if (command_fifo<0) { fprintf(stderr, "vegas_daq_server: Error opening control fifo\n"); perror("open"); exit(1); } /* Attach to shared memory buffers */ struct vegas_status stat; struct vegas_databuf *dbuf_net=NULL, *dbuf_pfb=NULL, *dbuf_acc=NULL; rv = vegas_status_attach(&stat); const int netbuf_id = 1; const int pfbbuf_id = 2; const int accbuf_id = 3; if (rv!=VEGAS_OK) { fprintf(stderr, "Error connecting to vegas_status\n"); exit(1); } dbuf_net = vegas_databuf_attach(netbuf_id); if (dbuf_net==NULL) { fprintf(stderr, "Error connecting to vegas_databuf (raw net)\n"); exit(1); } vegas_databuf_clear(dbuf_net); dbuf_pfb = vegas_databuf_attach(pfbbuf_id); if (dbuf_pfb==NULL) { fprintf(stderr, "Error connecting to vegas_databuf (accum input)\n"); exit(1); } vegas_databuf_clear(dbuf_pfb); dbuf_acc = vegas_databuf_attach(accbuf_id); if (dbuf_acc==NULL) { fprintf(stderr, "Error connecting to vegas_databuf (accum output)\n"); exit(1); } vegas_databuf_clear(dbuf_acc); /* Thread setup */ #define MAX_THREAD 8 int i; int nthread_cur = 0; struct vegas_thread_args args[MAX_THREAD]; pthread_t thread_id[MAX_THREAD]; for (i=0; i<MAX_THREAD; i++) thread_id[i] = 0; /* Print start time for logs */ time_t curtime = time(NULL); char tmp[256]; printf("\nvegas_daq_server started at %s", ctime_r(&curtime,tmp)); fflush(stdout); /* hmm.. keep this old signal stuff?? */ run=1; srv_run=1; signal(SIGINT, srv_cc); signal(SIGTERM, srv_quit); /* Loop over recv'd commands, process them */ int cmd_wait=1; while (cmd_wait && srv_run) { // Check to see if threads have exited, if so, stop them if (check_thread_exit(args, nthread_cur)) { run = 0; stop_threads(args, thread_id, nthread_cur); nthread_cur = 0; } // Heartbeat, status update time_t curtime; char timestr[32]; char *ctmp; time(&curtime); ctime_r(&curtime, timestr); ctmp = strchr(timestr, '\n'); if (ctmp!=NULL) { *ctmp = '\0'; } else { timestr[0]='\0'; } vegas_status_lock(&stat); hputs(stat.buf, "DAQPULSE", timestr); hputs(stat.buf, "DAQSTATE", nthread_cur==0 ? "stopped" : "running"); vegas_status_unlock(&stat); // Flush any status/error/etc for logfiles fflush(stdout); fflush(stderr); // Wait for data on fifo struct pollfd pfd; pfd.fd = command_fifo; pfd.events = POLLIN; rv = poll(&pfd, 1, 1000); if (rv==0) { continue; } else if (rv<0) { if (errno!=EINTR) perror("poll"); continue; } // If we got POLLHUP, it means the other side closed its // connection. Close and reopen the FIFO to clear this // condition. Is there a better/recommended way to do this? if (pfd.revents==POLLHUP) { close(command_fifo); command_fifo = open(vegas_DAQ_CONTROL, O_RDONLY | O_NONBLOCK); if (command_fifo<0) { fprintf(stderr, "vegas_daq_server: Error opening control fifo\n"); perror("open"); break; } continue; } // Read the command memset(cmd, 0, MAX_CMD_LEN); rv = read(command_fifo, cmd, MAX_CMD_LEN-1); if (rv==0) { continue; } else if (rv<0) { if (errno==EAGAIN) { continue; } else { perror("read"); continue; } } // Truncate at newline // TODO: allow multiple commands in one read? char *ptr = strchr(cmd, '\n'); if (ptr!=NULL) *ptr='\0'; // Process the command if (strncasecmp(cmd,"QUIT",MAX_CMD_LEN)==0) { // Exit program printf("Exit\n"); run = 0; stop_threads(args, thread_id, nthread_cur); cmd_wait=0; continue; } else if (strncasecmp(cmd,"START",MAX_CMD_LEN)==0 || strncasecmp(cmd,"MONITOR",MAX_CMD_LEN)==0) { // Start observations // TODO : decide how to behave if observations are running printf("Start observations\n"); if (nthread_cur>0) { printf(" observations already running!\n"); } else { // Figure out which mode to start char obs_mode[32]; if (strncasecmp(cmd,"START",MAX_CMD_LEN)==0) { vegas_status_lock(&stat); vegas_read_obs_mode(stat.buf, obs_mode); vegas_status_unlock(&stat); } else { strncpy(obs_mode, cmd, 32); } printf(" obs_mode = %s\n", obs_mode); // Clear out data bufs vegas_databuf_clear(dbuf_net); vegas_databuf_clear(dbuf_pfb); vegas_databuf_clear(dbuf_acc); // Do it run = 1; if (strncasecmp(obs_mode, "HBW", 4)==0) { hputs(stat.buf, "BW_MODE", "high"); hputs(stat.buf, "SWVER", "1.4"); init_hbw_mode(args, &nthread_cur); start_hbw_mode(args, thread_id); } else if (strncasecmp(obs_mode, "LBW", 4)==0) { hputs(stat.buf, "BW_MODE", "low"); hputs(stat.buf, "SWVER", "1.4"); init_lbw_mode(args, &nthread_cur); start_lbw_mode(args, thread_id); } else if (strncasecmp(obs_mode, "MONITOR", 8)==0) { init_monitor_mode(args, &nthread_cur); start_monitor_mode(args, thread_id); } else { printf(" unrecognized obs_mode!\n"); } } } else if (strncasecmp(cmd,"STOP",MAX_CMD_LEN)==0) { // Stop observations printf("Stop observations\n"); run = 0; stop_threads(args, thread_id, nthread_cur); nthread_cur = 0; } else { // Unknown command printf("Unrecognized command '%s'\n", cmd); } } /* Stop any running threads */ run = 0; stop_threads(args, thread_id, nthread_cur); if (command_fifo>0) close(command_fifo); vegas_status_lock(&stat); hputs(stat.buf, "DAQSTATE", "exiting"); vegas_status_unlock(&stat); curtime = time(NULL); printf("vegas_daq_server exiting cleanly at %s\n", ctime_r(&curtime,tmp)); fflush(stdout); fflush(stderr); /* TODO: remove FIFO */ exit(0); }
void main(int argc, char **argv) { const char *connect_file = DEFAULT_CONNECT_FILE; int server_fifo; const char *dir; char c2s[1000], s2c[1000], connect[2010]; int pid = getpid(); int rfd, wfd; int use_home_dir = 0; char *prog_name = argv[0]; while (--argc && **(++argv) == '-') { switch ((*argv)[1]) { case 'h': use_home_dir = 1; break; default: goto usage; } } if (argc == 1) connect_file = argv[0]; else if (argc != 0) goto usage; signal(SIGTERM, kill_signal); signal(SIGINT, kill_signal); signal(SIGQUIT, kill_signal); if (!use_home_dir || !(dir = getenv("HOME"))) dir = "/usr/tmp"; sprintf(c2s, "%s/.c2s-%05d", dir, (int) pid); sprintf(s2c, "%s/.s2c-%05d", dir, (int) pid); if (mkfifo(c2s, 0000) < 0 || chmod(c2s, 0644) < 0 || mkfifo(s2c, 0000) < 0 || chmod(s2c, 0622) < 0) { perror("Creating personal FIFOs"); goto die; } if ((rfd = open(s2c, O_RDONLY | NONBLOCK_FLAG)) < 0) { perror("Opening server-to-client FIFO"); goto die; } if ((server_fifo = open(connect_file, O_WRONLY | NONBLOCK_FLAG)) < 0) { perror("Opening server FIFO"); goto die; } sprintf(connect, "\n%s %s\n", c2s, s2c); write(server_fifo, connect, strlen(connect)); close(server_fifo); if ((wfd = open(c2s, O_WRONLY)) < 0) { perror("Opening client-to-server FIFO"); goto die; } remove(c2s); remove(s2c); fprintf(stderr, "[Connected to server]\n"); if (!set_non_blocking(0) || !set_non_blocking(rfd)) { perror("Setting connection non-blocking"); exit(1); } while (1) { char buffer[1024]; int count, did_some = 0; count = read(0, buffer, sizeof(buffer)); if (count > 0) { did_some = 1; write_all(wfd, buffer, count); } count = read(rfd, buffer, sizeof(buffer)); if (count > 0) { did_some = 1; if (buffer[count - 1] == '\0') { write_all(1, buffer, count - 1); break; } else write_all(1, buffer, count); } if (!did_some) sleep(1); } set_blocking(0); exit(0); die: remove(c2s); remove(s2c); exit(1); usage: fprintf(stderr, "Usage: %s [-h] [server-connect-file]\n", prog_name); exit(1); }
int pa__init(pa_module*m) { struct userdata *u; struct stat st; pa_sample_spec ss; pa_channel_map map; pa_modargs *ma; struct pollfd *pollfd; pa_sink_new_data data; pa_assert(m); if (!(ma = pa_modargs_new(m->argument, valid_modargs))) { pa_log("Failed to parse module arguments."); goto fail; } ss = m->core->default_sample_spec; map = m->core->default_channel_map; if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) { pa_log("Invalid sample format specification or channel map"); goto fail; } u = pa_xnew0(struct userdata, 1); u->core = m->core; u->module = m; m->userdata = u; pa_memchunk_reset(&u->memchunk); u->rtpoll = pa_rtpoll_new(); pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll); u->write_type = 0; u->filename = pa_runtime_path(pa_modargs_get_value(ma, "file", DEFAULT_FILE_NAME)); mkfifo(u->filename, 0666); if ((u->fd = open(u->filename, O_RDWR|O_NOCTTY)) < 0) { pa_log("open('%s'): %s", u->filename, pa_cstrerror(errno)); goto fail; } pa_make_fd_cloexec(u->fd); pa_make_fd_nonblock(u->fd); if (fstat(u->fd, &st) < 0) { pa_log("fstat('%s'): %s", u->filename, pa_cstrerror(errno)); goto fail; } if (!S_ISFIFO(st.st_mode)) { pa_log("'%s' is not a FIFO.", u->filename); goto fail; } pa_sink_new_data_init(&data); data.driver = __FILE__; data.module = m; pa_sink_new_data_set_name(&data, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME)); pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->filename); pa_proplist_setf(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Unix FIFO sink %s", u->filename); pa_sink_new_data_set_sample_spec(&data, &ss); pa_sink_new_data_set_channel_map(&data, &map); if (pa_modargs_get_proplist(ma, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) { pa_log("Invalid properties"); pa_sink_new_data_done(&data); goto fail; } u->sink = pa_sink_new(m->core, &data, PA_SINK_LATENCY); pa_sink_new_data_done(&data); if (!u->sink) { pa_log("Failed to create sink."); goto fail; } u->sink->parent.process_msg = sink_process_msg; u->sink->userdata = u; pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq); pa_sink_set_rtpoll(u->sink, u->rtpoll); pa_sink_set_max_request(u->sink, pa_pipe_buf(u->fd)); pa_sink_set_fixed_latency(u->sink, pa_bytes_to_usec(pa_pipe_buf(u->fd), &u->sink->sample_spec)); u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1); pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL); pollfd->fd = u->fd; pollfd->events = pollfd->revents = 0; if (!(u->thread = pa_thread_new(thread_func, u))) { pa_log("Failed to create thread."); goto fail; } pa_sink_put(u->sink); pa_modargs_free(ma); return 0; fail: if (ma) pa_modargs_free(ma); pa__done(m); return -1; }
int pipe_main(int argc, char *argv[]) { int filedes[2]; int ret; /* Test FIFO logic */ printf("\npipe_main: Performing FIFO test\n"); ret = mkfifo(FIFO_PATH1, 0666); if (ret < 0) { fprintf(stderr, "pipe_main: mkfifo failed with errno=%d\n", errno); return 1; } /* Open one end of the FIFO for reading and the other end for writing. NOTE: * the following might not work on most FIFO implementations because the attempt * to open just one end of the FIFO for writing might block. The NuttX FIFOs block * only on open for read-only (see interlock_test()). */ filedes[1] = open(FIFO_PATH1, O_WRONLY); if (filedes[1] < 0) { fprintf(stderr, "pipe_main: Failed to open FIFO %s for writing, errno=%d\n", FIFO_PATH1, errno); return 2; } filedes[0] = open(FIFO_PATH1, O_RDONLY); if (filedes[0] < 0) { fprintf(stderr, "pipe_main: Failed to open FIFO %s for reading, errno=%d\n", FIFO_PATH1, errno); if (close(filedes[1]) != 0) { fprintf(stderr, "pipe_main: close failed: %d\n", errno); } return 3; } /* Then perform the test using those file descriptors */ ret = transfer_test(filedes[0], filedes[1]); if (close(filedes[0]) != 0) { fprintf(stderr, "pipe_main: close failed: %d\n", errno); } if (close(filedes[1]) != 0) { fprintf(stderr, "pipe_main: close failed: %d\n", errno); } /* unlink(FIFO_PATH1); fails */ if (ret != 0) { fprintf(stderr, "pipe_main: FIFO test FAILED (%d)\n", ret); return 4; } printf("pipe_main: FIFO test PASSED\n"); /* Test PIPE logic */ printf("\npipe_main: Performing pipe test\n"); ret = pipe(filedes); if (ret < 0) { fprintf(stderr, "pipe_main: pipe failed with errno=%d\n", errno); return 5; } /* Then perform the test using those file descriptors */ ret = transfer_test(filedes[0], filedes[1]); if (close(filedes[0]) != 0) { fprintf(stderr, "pipe_main: close failed: %d\n", errno); } if (close(filedes[1]) != 0) { fprintf(stderr, "pipe_main: close failed: %d\n", errno); } if (ret != 0) { fprintf(stderr, "pipe_main: PIPE test FAILED (%d)\n", ret); return 6; } printf("pipe_main: PIPE test PASSED\n"); /* Perform the FIFO interlock test */ printf("\npipe_main: Performing pipe interlock test\n"); ret = interlock_test(); if (ret != 0) { fprintf(stderr, "pipe_main: FIFO interlock test FAILED (%d)\n", ret); return 7; } printf("pipe_main: PIPE interlock test PASSED\n"); /* Perform the pipe redirection test */ printf("\npipe_main: Performing redirection test\n"); ret = redirection_test(); if (ret != 0) { fprintf(stderr, "pipe_main: FIFO redirection test FAILED (%d)\n", ret); return 7; } printf("pipe_main: PIPE redirection test PASSED\n"); fflush(stdout); return 0; }
int main() { char buf[64]; pid_t cpid; int sfd, cfd, fd; int rnum; char pathname[64]; // make server fifo if(mkfifo(serverfifo, O_CREAT|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP) == -1) { perror("server mkfifo error"); //exit(-1); }else{ printf("create server fifo successfully.\n"); } // open server fifo and read pid of client, pathname from it if((sfd = open(serverfifo, O_RDONLY)) == -1) { perror("server open server fifo error"); exit(-1); }else{ printf("open server fifo in readonly mode successfully.\n"); } if((rnum = read(sfd, buf, sizeof(buf))) == -1) { perror("server read server fifo error"); exit(-1); }else{ printf("server: read:%s\n", buf); } sscanf(buf, "%d %s", &cpid, pathname); printf("server: get client pid: %d,pathname:%s\n", cpid, pathname); // close server fifo close(sfd); // open client fifo: writeonly snprintf(buf, sizeof(buf), "/tmp/client.%d.fifo", cpid); printf("server:client fifo is %s\n", buf); if((cfd = open(buf, O_WRONLY)) == -1) { perror("server:open client fifo error"); exit(-1); }else{ printf("open client fifo for writeonly\n"); } // open file:pathname, read it, and write its content to client fifo if((fd = open(pathname, O_RDONLY)) == -1) { perror("open pathname error."); exit(-1); }else{ printf("open pathname successfully.\n"); } while((rnum = read(fd, buf, sizeof(buf))) > 0) { write(cfd, buf, rnum); } // close client fifo, pathname close(fd); close(cfd); // delete server fifo unlink(serverfifo); return 0; }
int main(int argc, char * const *argv) { const char *infile = argv[1]; const char *outfile = argv[2]; int fd_in, fd_out; int opt; float rate = 0.0; bool exit_on_end = false; while ((opt = getopt(argc, argv, "r:e")) != -1) { switch (opt) { case 'r': rate = atof(optarg); break; case 'e': exit_on_end = true; break; } } again: fd_in = open(infile, O_RDONLY); if (fd_in == -1) { perror(infile); exit(1); } unlink(outfile); if (mkfifo(outfile, 0644) != 0) { perror(outfile); exit(1); } signal(SIGPIPE, SIG_IGN); printf("Waiting for connection ...\n"); fd_out = open(outfile, O_WRONLY); if (fd_out == -1) { perror(outfile); exit(1); } printf("Streaming ...\n"); while (1) { char buf[1024]; ssize_t n = read(fd_in, buf, sizeof(buf)); if (n <= 0) { if (exit_on_end) break; usleep(1000); continue; } if (write(fd_out, buf, n) == -1) { close(fd_out); close(fd_in); goto again; } if (rate != 0.0) { usleep(1.0e6/rate); } } printf("done\n"); return 0; }
int main(int argc,char *argv[]) { //sharepid //save what? user's name! //way 1: put it in a char[20], share a 20*512 space; //way 2: put it in longlong, then transfer it to char(use ascii) //e.g. abcd --> 'a' + [0,1,2,3,4] --> 05 'a' 01 02 03 04. only save half memory //improve: use '0' -- asc 48 as basic char, only need (num c0 c1 c2...) //I can use address! //but think about it: why share memory is invented? 'cause we needn't save it twice int userspace = shmget(IPC_PRIVATE,USRLEN*3,0666); char *temp = (char *)shmat(userspace,NULL,0); memset(temp,0,USRLEN*3); //commoninit mkfifo(LOGFILE,0666); mkfifo(PUBLIC,0666); int login=open(LOGFILE,O_RDONLY); char buf[1024]; int brunch=fork(); if(brunch==0)//listen login, and save the user name in shm { //one brunch loop here char lgname[USRLEN]; printf("1.1 start listening\n"); while(memset(lgname,0,USRLEN),read(login,lgname,USRLEN-1)!=0){ int iflogin=strcmp(lgname,""); if(iflogin) { //visit the share and add an element int *count = (int *)shmat(userspace,NULL,0); (*count)++; //if I share an address, when I fork, two copy will be Created //is it right to change the value by use the pointer? char *thisuser=(char *)(shmat(userspace,NULL,0)+*count*USRLEN); strncpy(thisuser,lgname,USRLEN); printf("1.2 some body login! %s\n",thisuser); //beter to open it in child, and write share memory.so problem: //if write too fast, we must add some lock to wait all finish reading } } }else{ //one for write to the users in shm, one for read from PUBLIC //keepwrite(); printf("2.1 for transfer success\n"); int pubpipe = open(PUBLIC,O_RDONLY); printf("2.2 pipe open suc\n"); int i; int fp[512]={0}; while(1){ int *count = (int *)shmat(userspace,NULL,0); for(i=1;i<=*count;i++) { char *p = (char *)(shmat(userspace,NULL,0)+i*USRLEN); printf("now user: %s %p\n",p,p); fp[i]=open(p,O_WRONLY); } memset(buf,0,1024); read(pubpipe,buf,1024); printf("%s",buf); if(strcmp(buf,"")==0) continue; if(strstr(buf,":")==NULL)//logoff operation { for(i = 1;i<=*count;i++) { char *p = (char *)shmat(userspace,NULL,0)+i*USRLEN; printf("now user: %s %p\n",p,p); if(strcmp(buf,p)==0){ write(fp[i],"EOF\0",4); memset(p,0,USRLEN); (*count)--; printf("%s is offline\n",buf); //now move element ,make sure no empty int j; break; } } for(i;i<=*count;i++) { char *p = (char *)shmat(userspace,NULL,0)+i*USRLEN; if(strcmp(p,"")==0){ strcpy(p,p+USRLEN); memset(p+USRLEN,0,USRLEN); } } continue; } printf("count = %d\n",*count); for(i=1;i<=*count;i++) { char *p = (char *)shmat(userspace,NULL,0)+i*USRLEN; write(fp[i],buf,1024); close(fp[i]); } } } }
int main() { int server_fifo_fd; int client_fifo_fd; int res; char client_fifo_name[NAME_SIZE]; MessageClient MC1; memset(&MC1, 0 , sizeof(MC1)); // if(UTIL_CheckFile(SERVER_FIFO_NAME)) { UTIL_DeleteFile(SERVER_FIFO_NAME); cout <<"Delete "<< SERVER_FIFO_NAME << endl; } if (mkfifo(SERVER_FIFO_NAME, 0777) == -1) { fprintf(stderr, "Sorry, create server fifo failure!\n"); exit(EXIT_FAILURE); } server_fifo_fd = open(SERVER_FIFO_NAME, O_RDONLY); if (server_fifo_fd == -1) { fprintf(stderr, "Sorry, server fifo open failure!\n"); exit(EXIT_FAILURE); } // sleep(5); // while ((res = read(server_fifo_fd, &CI, sizeof(CI))) > 0) int count =0; while (1) { //First read Operation Type if((res = read(server_fifo_fd, &MC1, sizeof(MC1))) > 0) { //CI.str="YYY"; ResultInfo RI; RI.result = SUCCEED; RI.MC.client_pid = MC1.client_pid; CourseInfo CI; LimitInfo LI; int OT = MC1.OT; switch(OT) { case Book: { if((res = read( server_fifo_fd, &CI, sizeof(CI))) > 0) { //sleep(4);//stand for do some post and get and annylyse //do the book thing string strHash ; strHash.assign(CI.Hash, strlen(CI.Hash)); Vhash1.push_back(strHash); //sleep(4);//stand for do some post and get and analyse cout << "Got a book :" << CI.Hash <<" " << MC1.client_pid << endl; } } break; case LimitSpeed: { if((res = read(server_fifo_fd, &LI, sizeof(LI))) > 0) { //do the Limit thing //sleep(4);//stand for do some post and get and annylyse cout << "LI.DownloadSpeedLimitTo :" << LI.DownloadSpeedLimitTo << endl; } } break; case Status: { //Vhash3.push_back(strHash); //cout << "Vhash3 size " << Vhash3.size() << endl; } break; default: break; } cout << count++ << endl; sprintf(client_fifo_name, CLIENT_FIFO_NAME, MC1.client_pid); client_fifo_fd = open(client_fifo_name, O_WRONLY); if (client_fifo_fd == -1) { fprintf(stderr, "Sorry, client fifo open failure!\n"); exit(EXIT_FAILURE); } write(client_fifo_fd, &RI, sizeof(RI)); close(client_fifo_fd); } else//keep try open { sleep(1);//need to sleep for a few second for it will make 100%cpu } } close(server_fifo_fd); unlink(SERVER_FIFO_NAME); exit(EXIT_SUCCESS); }
/* create_fifo() * Creates a new fifo with the given name and permission. */ static int create_fifo(char *name, int perm) { if ((mkfifo(name, perm) < 0) && (errno != EEXIST)) return -1; return 0; }
int usnet_init_shmmq(usn_shmmq_t *mq, char* fifo_path, int32_t wait_sec, int32_t wait_usec, int32_t shm_key, int32_t shm_size, int32_t sync) { int ret = 0; int val; char *mem_addr = NULL; int mode = 0666 | O_NONBLOCK | O_NDELAY; if ( mq == NULL ) { //ERROR("null pointer, addr=%p", mq); return -1; } errno = 0; if ((mkfifo(fifo_path, mode)) < 0) if (errno != EEXIST) { //ERROR("failed to make fifo, file=%s", fifo_path); ret = -1; goto done; } if ((mq->_fd = open(fifo_path, O_RDWR)) < 0) { ret = -2; //ERROR("failed to open fifo, file=%s", fifo_path); goto done; } if (mq->_fd > 1024) { close(mq->_fd); ret = -3; //ERROR("fd is too small, fd=%d", mq->_fd); goto done; } val = fcntl(mq->_fd, F_GETFL, 0); if (val == -1) { ret = errno ? -errno : val; //ERROR("failed to get fl, fd=%d", mq->_fd); goto done; } if (val & O_NONBLOCK) { ret = 0; goto done; } ret = fcntl(mq->_fd, F_SETFL, val | O_NONBLOCK | O_NDELAY); if (ret < 0) { ret = errno ? -errno : ret; //ERROR("failed to set fl, fd=%d, ret", mq->_fd, ret); goto done; } else ret = 0; assert(shm_size > C_HEAD_SIZE); mq->_shm = usnet_shm_create(shm_key, shm_size); if ( mq->_shm == NULL ) { mq->_shm = usnet_shm_open(shm_key, shm_size); if ( mq->_shm == NULL ) { ret = -1; //ERROR("failed to open shm, key=%d, size=%d", shm_key, shm_size); goto done; } mem_addr = mq->_shm->addr; goto setup; } else mem_addr = mq->_shm->addr; // init head portion of shared meme. memset(mem_addr, 0, C_HEAD_SIZE * 2 + sizeof(*mq->_adaptive_ctrl)); // init adaptive control. mq->_adaptive_ctrl = (usn_adapctl_t *)mem_addr; mq->_adaptive_ctrl->m_uiCheckTimeSpan = 1; mq->_adaptive_ctrl->m_uiMsgCount = 0; mq->_adaptive_ctrl->m_uiLastCheckTime = time(NULL); mq->_adaptive_ctrl->m_uiLastFactor = 1; mq->_adaptive_ctrl->m_uiFactor = 1; mq->_adaptive_ctrl->m_uiSync = sync; mq->_wait_sec = wait_sec; mq->_wait_usec = wait_usec; setup: mq->_adaptive_ctrl = (usn_adapctl_t *)mem_addr; mem_addr += sizeof(*mq->_adaptive_ctrl); mq->_enqueued_msg_cnt = (uint32_t*)mem_addr; mq->_dequeued_msg_cnt = (uint32_t*)mem_addr + 1; // set head and tail mq->_head = (uint32_t*)mem_addr + 2; mq->_tail = mq->_head+1; mq->_block = (char*) (mq->_tail+1); mq->_block_size = shm_size - ( C_HEAD_SIZE * 2 + sizeof(*mq->_adaptive_ctrl) ); ret = 0; done: return ret; }
int sample_event() { struct event evfifo; #ifdef WIN32 HANDLE socket; /* Open a file. */ socket = CreateFileA("test.txt", /* open File */ GENERIC_READ | GENERIC_WRITE, /* open for reading */ FILE_SHARE_READ, /* do not share */ NULL, /* no security */ OPEN_ALWAYS, /* existing file only */ FILE_ATTRIBUTE_NORMAL, /* normal file */ NULL); /* no attr. template */ if (socket == INVALID_HANDLE_VALUE) return 1; #else struct stat st; const char *fifo = "event.fifo"; int socket; if (lstat(fifo, &st) == 0) { if ((st.st_mode & S_IFMT) == S_IFREG) { errno = EEXIST; perror("lstat"); exit(1); } } unlink(fifo); if (mkfifo(fifo, 0600) == -1) { perror("mkfifo"); exit(1); } /* Linux pipes are broken, we need O_RDWR instead of O_RDONLY */ #ifdef __linux socket = open(fifo, O_RDWR | O_NONBLOCK, 0); #else socket = open(fifo, O_RDONLY | O_NONBLOCK, 0); #endif if (socket == -1) { perror("open"); exit(1); } fprintf(stderr, "Write data to %s\n", fifo); #endif /* Initalize the event library */ event_init(); /* Initalize one event */ #ifdef WIN32 event_set(&evfifo, (evutil_socket_t)socket, EV_READ, fifo_read, &evfifo); #else event_set(&evfifo, socket, EV_READ, fifo_read, &evfifo); #endif /* Add it to the active events, without a timeout */ event_add(&evfifo, NULL); event_dispatch(); #ifdef WIN32 CloseHandle(socket); #endif return (0); }
void *carAssistant(void *car){ //Variable which will be used to store the time clock_t t; //Stores the car's information in new variables for easier handling struct carAssistInfo *info = (struct carInfo *) car; int idCar = info->idCar; int parkingTime = info->parkingTime; int messagelen; char message[100]; //Creates a new fifo for the car using the car's unique ID char * fifoCar = malloc (sizeof (char)); sprintf(fifoCar, "car%d", idCar); mkfifo(fifoCar,FIFO_PERMISSIONS); //Opens the car's fifo for writing int fdA = open(fifoCar, O_WRONLY); //Locks the access to a critical section pthread_mutex_lock(&nLugaresLock); //If the park is not full if(n_lugares> 0) { //If there is only one spot left the car enters and the park is now full if(n_lugares == 1){ //Registers current time to print in log t = clock(); pthread_mutex_lock(&nLugLock); //Registers that there is one more car in the park nLug++; //Prints to log printToLog (t, nLug, idCar, "cheio"); pthread_mutex_unlock(&nLugLock); }else{ //Registers current time to print in log t = clock(); pthread_mutex_lock(&nLugLock); //Registers that there is one more car in the park nLug++; //Prints to log printToLog (t, nLug, idCar, "estacionamento"); pthread_mutex_unlock(&nLugLock); } //Registers that there is one less available spot in the park n_lugares--; sprintf(message,"Entrou!"); messagelen=strlen(message)+1; //Transmits to the vehicle tracker thread that the car has entered write(fdA,message,messagelen); pthread_mutex_unlock(&nLugaresLock); //The car is parked of the amount that it wants to be sleepTicks(parkingTime); pthread_mutex_lock(&nLugaresLock); //The car leaves and there is another spot in the park n_lugares++; pthread_mutex_unlock(&nLugaresLock); pthread_mutex_lock(&nLugLock); //Registers current time t = clock(); nLug--; //If the park is opened, the car leaves, else prints that it is closed and won't receive any more cars if(opened==0){ printToLog (t, nLug, idCar, "encerrado"); }else{ printToLog (t, nLug, idCar, "saida"); } pthread_mutex_unlock(&nLugLock); //Writes to the car's fifo that it left sprintf(message,"Saiu!"); write(fdA,message,messagelen); close(fdA); } //If the park is full: else { sprintf(message,"Cheio!"); messagelen=strlen(message)+1; write(fdA,message,messagelen); pthread_mutex_unlock(&nLugaresLock); close(fdA); } }
int acl_fifo_listen(const char *path, int permissions, int block_mode) { char *myname = "acl_fifo_listen"; char buf[BUF_LEN], tbuf[256]; static int open_mode = 0; struct stat st; int fd; int count; /* * Create a named pipe (fifo). Do whatever we can so we don't run into * trouble when this process is restarted after crash. Make sure that * we open a fifo and not something else, then change permissions to * what we wanted them to be, because mkfifo() is subject to umask * settings. Instead we could zero the umask temporarily before * creating the FIFO, but that would cost even more system calls. * Figure out if the fifo needs to be opened O_RDWR or O_RDONLY. Some * systems need one, some need the other. If we choose the wrong mode, * the fifo will stay readable, causing the program to go into a loop. */ if (unlink(path) && acl_last_error() != ENOENT) { acl_msg_error("%s: remove %s: %s", myname, path, acl_last_strerror(tbuf, sizeof(tbuf))); return -1; } if (mkfifo(path, permissions) < 0) { acl_msg_error("%s: create fifo %s: %s", myname, path, acl_last_strerror(tbuf, sizeof(tbuf))); return -1; } switch (open_mode) { case 0: if ((fd = open(path, O_RDWR | O_NONBLOCK, 0)) < 0) { acl_msg_error("%s: open %s: %s", myname, path, acl_last_strerror(tbuf, sizeof(tbuf))); return -1; } if (acl_readable(fd) == 0) { open_mode = O_RDWR | O_NONBLOCK; break; } open_mode = O_RDONLY | O_NONBLOCK; if (acl_msg_verbose) acl_msg_info("open O_RDWR makes fifo readable" " - trying O_RDONLY"); (void) close(fd); if ((fd = open(path, open_mode, 0)) < 0) { acl_msg_error("%s: open %s: %s", myname, path, acl_last_strerror(tbuf, sizeof(tbuf))); return -1; } break; default: if ((fd = open(path, open_mode, 0)) < 0) { acl_msg_error("%s: open %s: %s", myname, path, acl_last_strerror(tbuf, sizeof(tbuf))); return -1; } break; } /* * Make sure we opened a FIFO and skip any cruft that might have * accumulated before we opened it. */ if (fstat(fd, &st) < 0) { acl_msg_error("%s: fstat %s: %s", myname, path, acl_last_strerror(tbuf, sizeof(tbuf))); close(fd); return -1; } if (S_ISFIFO(st.st_mode) == 0) { acl_msg_error("%s: not a fifo: %s", myname, path); close(fd); return -1; } if (fchmod(fd, permissions) < 0) { acl_msg_error("%s: fchmod %s: %s", myname, path, acl_last_strerror(tbuf, sizeof(tbuf))); close(fd); return -1; } acl_non_blocking(fd, block_mode); while ((count = acl_peekfd(fd)) > 0 && read(fd, buf, BUF_LEN < count ? BUF_LEN : count) > 0) { } return fd; }