DiskRipper::DiskRipper(QString *filter,QString *group,QString *schedcode, bool profile_rip,QWidget *parent,const char *name) : QDialog(parent,name) { rip_isrc_read=false; rip_filter_text=filter; rip_group_text=group; rip_schedcode_text=schedcode; rip_profile_rip=profile_rip; rip_aborting=false; // // Fix the Window Size // setMinimumWidth(sizeHint().width()); setMinimumHeight(sizeHint().height()); // // Generate Fonts // QFont button_font=QFont("Helvetica",12,QFont::Bold); button_font.setPixelSize(12); QFont label_font=QFont("Helvetica",12,QFont::Bold); label_font.setPixelSize(12); setCaption(tr("Rip Disk")); // // Create Dialogs // rip_wavedata_dialog=new RDWaveDataDialog("RDLibrary",this); // // Create Temporary Directory // char path[PATH_MAX]; strncpy(path,RDTempDir(),PATH_MAX); strcat(path,"/XXXXXX"); if(mkdtemp(path)==NULL) { QMessageBox::warning(this,"RDLibrary - "+tr("Ripper Error"), tr("Unable to create temporary directory!")); } else { rip_cdda_dir.setPath(path); } // // The CDROM Drive // if(rip_profile_rip) { rip_cdrom=new RDCdPlayer(stdout,this); } else { rip_cdrom=new RDCdPlayer(NULL,this); } connect(rip_cdrom,SIGNAL(ejected()),this,SLOT(ejectedData())); connect(rip_cdrom,SIGNAL(mediaChanged()),this,SLOT(mediaChangedData())); connect(rip_cdrom,SIGNAL(played(int)),this,SLOT(playedData(int))); connect(rip_cdrom,SIGNAL(stopped()),this,SLOT(stoppedData())); rip_cdrom->setDevice(rdlibrary_conf->ripperDevice()); rip_cdrom->open(); // // CDDB Stuff // if(rip_profile_rip) { rip_cddb_lookup=new RDCddbLookup(stdout,this); } else { rip_cddb_lookup=new RDCddbLookup(NULL,this); } connect(rip_cddb_lookup,SIGNAL(done(RDCddbLookup::Result)), this,SLOT(cddbDoneData(RDCddbLookup::Result))); // // Artist Label // QLabel *label=new QLabel(tr("Artist:"),this); label->setGeometry(10,10,50,18); label->setFont(label_font); label->setAlignment(AlignRight|AlignVCenter); rip_artist_edit=new QLineEdit(this); // // Album Edit // label=new QLabel(tr("Album:"),this); label->setGeometry(10,32,50,18); label->setFont(label_font); label->setAlignment(AlignRight|AlignVCenter); rip_album_edit=new QLineEdit(this); // // Other Edit // label=new QLabel(tr("Other:"),this); label->setGeometry(10,54,50,16); label->setFont(label_font); label->setAlignment(AlignRight); rip_other_edit=new QTextEdit(this); rip_other_edit->setReadOnly(true); // // Apply FreeDB Check Box // rip_apply_box=new QCheckBox(this,"rip_apply_box"); rip_apply_box->setChecked(true); rip_apply_box->setDisabled(true); rip_apply_label= new QLabel(rip_apply_box,tr("Apply FreeDB Values to Carts"),this); rip_apply_label->setFont(label_font); rip_apply_label->setAlignment(AlignLeft); rip_apply_box->setChecked(false); rip_apply_label->setDisabled(true); // // Track List // rip_track_list=new QListView(this); rip_track_list->setAllColumnsShowFocus(true); rip_track_list->setItemMargin(5); rip_track_list->setSorting(-1); rip_track_list->setSelectionMode(QListView::Extended); connect(rip_track_list,SIGNAL(selectionChanged()), this,SLOT(selectionChangedData())); connect(rip_track_list, SIGNAL(doubleClicked(QListViewItem *,const QPoint &,int)), this, SLOT(doubleClickedData(QListViewItem *,const QPoint &,int))); rip_track_label=new QLabel(rip_track_list,tr("Tracks"),this); rip_track_label->setFont(label_font); rip_track_list->addColumn(tr("TRACK")); rip_track_list->setColumnAlignment(0,Qt::AlignHCenter); rip_track_list->addColumn(tr("LENGTH")); rip_track_list->setColumnAlignment(1,Qt::AlignRight); rip_track_list->addColumn(tr("TITLE")); rip_track_list->setColumnAlignment(2,Qt::AlignLeft); rip_track_list->addColumn(tr("OTHER")); rip_track_list->setColumnAlignment(3,Qt::AlignLeft); rip_track_list->addColumn(tr("TYPE")); rip_track_list->setColumnAlignment(4,Qt::AlignLeft); rip_track_list->addColumn(tr("CUT")); rip_track_list->setColumnAlignment(5,Qt::AlignLeft); // // Progress Bars // rip_disk_bar=new QProgressBar(this); rip_diskbar_label=new QLabel(tr("Disk Progress"),this); rip_diskbar_label->setFont(label_font); rip_diskbar_label->setAlignment(AlignLeft|AlignVCenter); rip_diskbar_label->setDisabled(true); rip_track_bar=new QProgressBar(this); rip_trackbar_label=new QLabel(tr("Track Progress"),this); rip_trackbar_label->setFont(label_font); rip_trackbar_label->setAlignment(AlignLeft|AlignVCenter); rip_trackbar_label->setDisabled(true); // // Eject Button // rip_eject_button=new RDTransportButton(RDTransportButton::Eject,this); connect(rip_eject_button,SIGNAL(clicked()),this,SLOT(ejectButtonData())); // // Play Button // rip_play_button=new RDTransportButton(RDTransportButton::Play,this); connect(rip_play_button,SIGNAL(clicked()),this,SLOT(playButtonData())); // // Stop Button // rip_stop_button=new RDTransportButton(RDTransportButton::Stop,this); rip_stop_button->setOnColor(red); rip_stop_button->on(); connect(rip_stop_button,SIGNAL(clicked()),this,SLOT(stopButtonData())); // // Set Cut Button // rip_setcut_button=new QPushButton(tr("Set\n&Cart/Cut"),this); rip_setcut_button->setFont(button_font); rip_setcut_button->setDisabled(true); connect(rip_setcut_button,SIGNAL(clicked()),this,SLOT(setCutButtonData())); // // Set Multi Tracks Button // rip_setall_button=new QPushButton(tr("Add Cart\nPer Track"),this); rip_setall_button->setFont(button_font); rip_setall_button->setDisabled(true); connect(rip_setall_button,SIGNAL(clicked()),this,SLOT(setMultiButtonData())); // // Set Single Button // rip_setsingle_button=new QPushButton(tr("Add Single\nCart"),this); rip_setsingle_button->setFont(button_font); rip_setsingle_button->setDisabled(true); connect(rip_setsingle_button,SIGNAL(clicked()), this,SLOT(setSingleButtonData())); // // Set Cart Label Button // rip_cartlabel_button=new QPushButton(tr("Modify\nCart Label"),this); rip_cartlabel_button->setFont(button_font); rip_cartlabel_button->setDisabled(true); connect(rip_cartlabel_button,SIGNAL(clicked()), this,SLOT(modifyCartLabelData())); // // Clear Selection Button // rip_clear_button=new QPushButton(tr("Clear\nSelection"),this); rip_clear_button->setFont(button_font); rip_clear_button->setDisabled(true); connect(rip_clear_button,SIGNAL(clicked()),this,SLOT(clearSelectionData())); // // Normalize Check Box // rip_normalize_box=new QCheckBox(this); rip_normalize_box->setChecked(true); rip_normalizebox_label=new QLabel(rip_normalize_box,tr("Normalize"),this); rip_normalizebox_label->setFont(label_font); rip_normalizebox_label->setAlignment(AlignLeft|AlignVCenter); connect(rip_normalize_box,SIGNAL(toggled(bool)), this,SLOT(normalizeCheckData(bool))); // // Normalize Level // rip_normalize_spin=new QSpinBox(this); rip_normalize_spin->setRange(-30,0); rip_normalize_label=new QLabel(rip_normalize_spin,tr("Level:"),this); rip_normalize_label->setFont(label_font); rip_normalize_label->setAlignment(AlignRight|AlignVCenter); rip_normalize_unit=new QLabel(tr("dBFS"),this); rip_normalize_unit->setFont(label_font); rip_normalize_unit->setAlignment(AlignLeft|AlignVCenter); // // Autotrim Check Box // rip_autotrim_box=new QCheckBox(this); rip_autotrim_box->setChecked(true); rip_autotrimbox_label=new QLabel(rip_autotrim_box,tr("Autotrim"),this); rip_autotrimbox_label->setFont(label_font); rip_autotrimbox_label->setAlignment(AlignLeft|AlignVCenter); connect(rip_autotrim_box,SIGNAL(toggled(bool)), this,SLOT(autotrimCheckData(bool))); // // Autotrim Level // rip_autotrim_spin=new QSpinBox(this); rip_autotrim_spin->setRange(-99,0); rip_autotrim_label=new QLabel(rip_autotrim_spin,tr("Level:"),this); rip_autotrim_label->setFont(label_font); rip_autotrim_label->setAlignment(AlignRight|AlignVCenter); rip_autotrim_unit=new QLabel(tr("dBFS"),this); rip_autotrim_unit->setFont(label_font); rip_autotrim_unit->setAlignment(AlignLeft|AlignVCenter); // // Channels // rip_channels_box=new QComboBox(this); rip_channels_label=new QLabel(rip_channels_box,tr("Channels:"),this); rip_channels_label->setFont(label_font); rip_channels_label->setAlignment(AlignRight|AlignVCenter); // // Rip Disc Button // rip_rip_button=new QPushButton(tr("&Rip\nDisc"),this); rip_rip_button->setFont(button_font); connect(rip_rip_button,SIGNAL(clicked()),this,SLOT(ripDiskButtonData())); rip_rip_button->setDisabled(true); // // Close Button // rip_close_button=new QPushButton(tr("&Close"),this); rip_close_button->setFont(button_font); connect(rip_close_button,SIGNAL(clicked()),this,SLOT(closeData())); // // Populate Data // rip_normalize_spin->setValue(rdlibrary_conf->ripperLevel()/100); rip_autotrim_spin->setValue(rdlibrary_conf->trimThreshold()/100); rip_channels_box->insertItem("1"); rip_channels_box->insertItem("2"); rip_channels_box->setCurrentItem(rdlibrary_conf->defaultChannels()-1); rip_done=false; }
int main(int argc, char *argv[]) { struct stat stbuf; struct statfs statfsbuf, totalbuf; struct maxwidths maxwidths; struct statfs *mntbuf; const char *fstype; char *mntpath, *mntpt; const char **vfslist; int i, mntsize; int ch, rv; fstype = "ufs"; (void)setlocale(LC_ALL, ""); memset(&totalbuf, 0, sizeof(totalbuf)); totalbuf.f_bsize = DEV_BSIZE; strlcpy(totalbuf.f_mntfromname, "total", MNAMELEN); vfslist = NULL; while ((ch = getopt(argc, argv, "abcgHhiklmnPt:T,")) != -1) switch (ch) { case 'a': aflag = 1; break; case 'b': /* FALLTHROUGH */ case 'P': /* * POSIX specifically discusses the behavior of * both -k and -P. It states that the blocksize should * be set to 1024. Thus, if this occurs, simply break * rather than clobbering the old blocksize. */ if (kflag) break; setenv("BLOCKSIZE", "512", 1); hflag = 0; break; case 'c': cflag = 1; break; case 'g': setenv("BLOCKSIZE", "1g", 1); hflag = 0; break; case 'H': hflag = UNITS_SI; break; case 'h': hflag = UNITS_2; break; case 'i': iflag = 1; break; case 'k': kflag++; setenv("BLOCKSIZE", "1024", 1); hflag = 0; break; case 'l': if (vfslist != NULL) errx(1, "-l and -t are mutually exclusive."); vfslist = makevfslist(makenetvfslist()); lflag = 1; break; case 'm': setenv("BLOCKSIZE", "1m", 1); hflag = 0; break; case 'n': nflag = 1; break; case 't': if (lflag) errx(1, "-l and -t are mutually exclusive."); if (vfslist != NULL) errx(1, "only one -t option may be specified"); fstype = optarg; vfslist = makevfslist(optarg); break; case 'T': Tflag = 1; break; case ',': thousands = 1; break; case '?': default: usage(); } argc -= optind; argv += optind; rv = 0; if (!*argv) { /* everything (modulo -t) */ mntsize = getmntinfo(&mntbuf, MNT_NOWAIT); mntsize = regetmntinfo(&mntbuf, mntsize, vfslist); } else { /* just the filesystems specified on the command line */ mntbuf = malloc(argc * sizeof(*mntbuf)); if (mntbuf == 0) err(1, "malloc()"); mntsize = 0; /* continued in for loop below */ } /* iterate through specified filesystems */ for (; *argv; argv++) { if (stat(*argv, &stbuf) < 0) { if ((mntpt = getmntpt(*argv)) == 0) { warn("%s", *argv); rv = 1; continue; } } else if (S_ISCHR(stbuf.st_mode)) { if ((mntpt = getmntpt(*argv)) == 0) { mdev.fspec = *argv; mntpath = strdup("/tmp/df.XXXXXX"); if (mntpath == NULL) { warn("strdup failed"); rv = 1; continue; } mntpt = mkdtemp(mntpath); if (mntpt == NULL) { warn("mkdtemp(\"%s\") failed", mntpath); rv = 1; free(mntpath); continue; } if (mount(fstype, mntpt, MNT_RDONLY, &mdev) != 0) { warn("%s", *argv); rv = 1; (void)rmdir(mntpt); free(mntpath); continue; } else if (statfs(mntpt, &statfsbuf) == 0) { statfsbuf.f_mntonname[0] = '\0'; prtstat(&statfsbuf, &maxwidths); if (cflag) addstat(&totalbuf, &statfsbuf); } else { warn("%s", *argv); rv = 1; } (void)unmount(mntpt, 0); (void)rmdir(mntpt); free(mntpath); continue; } } else mntpt = *argv; /* * Statfs does not take a `wait' flag, so we cannot * implement nflag here. */ if (statfs(mntpt, &statfsbuf) < 0) { warn("%s", mntpt); rv = 1; continue; } /* * Check to make sure the arguments we've been given are * satisfied. Return an error if we have been asked to * list a mount point that does not match the other args * we've been given (-l, -t, etc.). */ if (checkvfsname(statfsbuf.f_fstypename, vfslist)) { rv = 1; continue; } /* the user asked for it, so ignore the ignore flag */ statfsbuf.f_flags &= ~MNT_IGNORE; /* add to list */ mntbuf[mntsize++] = statfsbuf; } bzero(&maxwidths, sizeof(maxwidths)); for (i = 0; i < mntsize; i++) { if (aflag || (mntbuf[i].f_flags & MNT_IGNORE) == 0) { update_maxwidths(&maxwidths, &mntbuf[i]); if (cflag) addstat(&totalbuf, &mntbuf[i]); } } for (i = 0; i < mntsize; i++) if (aflag || (mntbuf[i].f_flags & MNT_IGNORE) == 0) prtstat(&mntbuf[i], &maxwidths); if (cflag) prtstat(&totalbuf, &maxwidths); return (rv); }
int main(int argc, char* const argv[]) { // set those right away so that *print* statements don't fail stapsh_in = stdin; stapsh_out = stdout; stapsh_err = stderr; parse_args(argc, argv); // we're gonna need this for setup_signals so let's do it now if (uname(&uts)) die("Error calling uname"); setup_signals(); if (listening_port != NULL) { listening_port_fd = open(listening_port, O_RDWR); if (listening_port_fd == -1) // no one might be watching but might as well print die("Error calling open()"); if (can_sigio()) { // make ourselves the recipient of SIGIO signals for this port if (fcntl(listening_port_fd, F_SETOWN, getpid()) < 0) die("Error calling fcntl F_SETOWN"); // add O_ASYNC flag to enable SIGIO notifications on this port int flags = fcntl(listening_port_fd, F_GETFL); if (flags == -1) die("Error calling fcntl F_GETFL"); if (fcntl(listening_port_fd, F_SETFL, flags | O_ASYNC) == -1) die("Error calling fcntl F_SETFL"); } // We need to have different FILE* for each direction, otherwise // we'll have trouble down the line due to stdio's buffering // (doing "r+" on sockets is very wonky) stapsh_in = fdopen(listening_port_fd, "r"); stapsh_out = fdopen(listening_port_fd, "w"); stapsh_err = stapsh_out; if (!stapsh_in || !stapsh_out) die("Could not open serial port"); } umask(0077); snprintf(tmpdir, sizeof(tmpdir), "%s/stapsh.XXXXXX", getenv("TMPDIR") ?: "/tmp"); if (!mkdtemp(tmpdir)) die ("Can't make a temporary working directory"); if (chdir(tmpdir)) die ("Can't change to temporary working directory \"%s\"", tmpdir); // Prep pfds. For now we're only interested in commands from stap, and we // don't poll staprun until it is started. pfds[PFD_STAP_OUT].fd = fileno(stapsh_in); pfds[PFD_STAP_OUT].events = POLLIN; pfds[PFD_STAPRUN_OUT].events = 0; pfds[PFD_STAPRUN_ERR].events = 0; // Wait until a host connects before entering the command loop or poll() will // return with POLLHUP right away. Note that sleep() will be interrupted upon // SIGIO. if (listening_port != NULL) while (!host_connected()) sleep(2); // Once we support only platforms with guaranteed SIGIO support, // we could replace this with a pause(). // keep polling as long as we're listening for stap commands while (pfds[PFD_STAP_OUT].events) { if (poll(pfds, 3, -1) < 0) { if (errno == EINTR) continue; // go back to poll() else die ("poll() failed with critical error"); } if (pfds[PFD_STAP_OUT].revents & POLLHUP) break; if (pfds[PFD_STAP_OUT].revents & POLLIN) process_command(); if (pfds[PFD_STAPRUN_OUT].revents & POLLIN) prefix_staprun(PFD_STAPRUN_OUT, stapsh_out, "stdout"); if (pfds[PFD_STAPRUN_ERR].revents & POLLIN) prefix_staprun(PFD_STAPRUN_ERR, stapsh_err, "stderr"); } cleanup(0); }
char* make_directory() { char* templ = strdup("/tmp/rubinius_TestDir.XXXXXX"); return mkdtemp(templ); }
int main(int argc, char *const argv[]) { char tmpdir[] = "/tmp/dirXXXXXX"; char cmd[128]; char filepnm[128] = ""; char *dev; struct lr_server_data lsd; FILE *filep = NULL; int ret; int c; int opt_client = 0; int opt_reply = 0; progname = argv[0]; while ((c = getopt_long(argc, argv, "chr", long_opts, NULL)) != -1) { switch (c) { case 'c': opt_client = 1; break; case 'r': opt_reply = 1; break; case 'h': default: display_usage(); return -1; } } dev = argv[optind]; if (!dev) { display_usage(); return -1; } /* Make a temporary directory to hold Lustre data files. */ if (!mkdtemp(tmpdir)) { fprintf(stderr, "%s: Can't create temporary directory %s: %s\n", progname, tmpdir, strerror(errno)); return errno; } memset(cmd, 0, sizeof(cmd)); snprintf(cmd, sizeof(cmd), "%s -c -R 'dump /%s %s/%s' %s", DEBUGFS, LAST_RCVD, tmpdir, LAST_RCVD, dev); ret = run_command(cmd, sizeof(cmd)); if (ret) { fprintf(stderr, "%s: Unable to dump %s file\n", progname, LAST_RCVD); goto out_rmdir; } snprintf(filepnm, 128, "%s/%s", tmpdir, LAST_RCVD); filep = fopen(filepnm, "r"); if (!filep) { fprintf(stderr, "%s: Unable to read old data\n", progname); ret = -errno; goto out_rmdir; } unlink(filepnm); /* read lr_server_data structure */ printf("%s:\n", LAST_RCVD); ret = fread(&lsd, 1, sizeof(lsd), filep); if (ret < sizeof(lsd)) { fprintf(stderr, "%s: Short read (%d of %d)\n", progname, ret, (int)sizeof(lsd)); ret = -ferror(filep); if (ret) goto out_close; } /* swab structure fields of interest */ lsd.lsd_feature_compat = __le32_to_cpu(lsd.lsd_feature_compat); lsd.lsd_feature_incompat = __le32_to_cpu(lsd.lsd_feature_incompat); lsd.lsd_feature_rocompat = __le32_to_cpu(lsd.lsd_feature_rocompat); lsd.lsd_last_transno = __le64_to_cpu(lsd.lsd_last_transno); lsd.lsd_osd_index = __le32_to_cpu(lsd.lsd_osd_index); lsd.lsd_mount_count = __le64_to_cpu(lsd.lsd_mount_count); /* display */ printf(" uuid: %.40s\n", lsd.lsd_uuid); printf(" feature_compat: %#x\n", lsd.lsd_feature_compat); printf(" feature_incompat: %#x\n", lsd.lsd_feature_incompat); printf(" feature_rocompat: %#x\n", lsd.lsd_feature_rocompat); printf(" last_transaction: %llu\n", lsd.lsd_last_transno); printf(" target_index: %u\n", lsd.lsd_osd_index); printf(" mount_count: %llu\n", lsd.lsd_mount_count); /* read client information */ if (opt_client) { lsd.lsd_client_start = __le32_to_cpu(lsd.lsd_client_start); lsd.lsd_client_size = __le16_to_cpu(lsd.lsd_client_size); printf(" client_area_start: %u\n", lsd.lsd_client_start); printf(" client_area_size: %hu\n", lsd.lsd_client_size); /* seek to per-client data area */ ret = fseek(filep, lsd.lsd_client_start, SEEK_SET); if (ret) { fprintf(stderr, "%s: seek failed. %s\n", progname, strerror(errno)); ret = errno; goto out_close; } /* walk throuh the per-client data area */ while (true) { struct lsd_client_data lcd; /* read a per-client data area */ ret = fread(&lcd, 1, sizeof(lcd), filep); if (ret < sizeof(lcd)) { if (feof(filep)) break; fprintf(stderr, "%s: Short read (%d of %d)\n", progname, ret, (int)sizeof(lcd)); ret = -ferror(filep); goto out_close; } if (lcd.lcd_uuid[0] == '\0') continue; /* swab structure fields */ lcd.lcd_last_transno = __le64_to_cpu(lcd.lcd_last_transno); lcd.lcd_last_xid = __le64_to_cpu(lcd.lcd_last_xid); lcd.lcd_last_result = __le32_to_cpu(lcd.lcd_last_result); lcd.lcd_last_data = __le32_to_cpu(lcd.lcd_last_data); lcd.lcd_generation = __le32_to_cpu(lcd.lcd_generation); /* display per-client data area */ printf("\n %.40s:\n", lcd.lcd_uuid); printf(" generation: %u\n", lcd.lcd_generation); printf(" last_transaction: %llu\n", lcd.lcd_last_transno); printf(" last_xid: %llu\n", lcd.lcd_last_xid); printf(" last_result: %u\n", lcd.lcd_last_result); printf(" last_data: %u\n", lcd.lcd_last_data); if (lcd.lcd_last_close_transno != 0 && lcd.lcd_last_close_xid != 0) { lcd.lcd_last_close_transno = __le64_to_cpu(lcd.lcd_last_close_transno); lcd.lcd_last_close_xid = __le64_to_cpu(lcd.lcd_last_close_xid); lcd.lcd_last_close_result = __le32_to_cpu(lcd.lcd_last_close_result); lcd.lcd_last_close_data = __le32_to_cpu(lcd.lcd_last_close_data); printf(" last_close_transation: %llu\n", lcd.lcd_last_close_transno); printf(" last_close_xid: %llu\n", lcd.lcd_last_close_xid); printf(" last_close_result: %u\n", lcd.lcd_last_close_result); printf(" last_close_data: %u\n", lcd.lcd_last_close_data); } } } fclose(filep); filep = NULL; /* read reply data information */ if (opt_reply) { struct lsd_reply_header lrh; struct lsd_reply_data lrd; unsigned long long slot; snprintf(cmd, sizeof(cmd), "%s -c -R 'dump /%s %s/%s' %s", DEBUGFS, REPLY_DATA, tmpdir, REPLY_DATA, dev); ret = run_command(cmd, sizeof(cmd)); if (ret) { fprintf(stderr, "%s: Unable to dump %s file\n", progname, REPLY_DATA); goto out_rmdir; } snprintf(filepnm, sizeof(filepnm), "%s/%s", tmpdir, REPLY_DATA); filep = fopen(filepnm, "r"); if (!filep) { fprintf(stderr, "%s: Unable to read reply data\n", progname); ret = -errno; goto out_rmdir; } unlink(filepnm); /* read reply_data header */ printf("\n%s:\n", REPLY_DATA); ret = fread(&lrh, 1, sizeof(lrh), filep); if (ret < sizeof(lrh)) { fprintf(stderr, "%s: Short read (%d of %d)\n", progname, ret, (int)sizeof(lrh)); ret = -ferror(filep); if (ret) goto out_close; } /* check header */ lrh.lrh_magic = __le32_to_cpu(lrh.lrh_magic); lrh.lrh_header_size = __le32_to_cpu(lrh.lrh_header_size); lrh.lrh_reply_size = __le32_to_cpu(lrh.lrh_reply_size); if (lrh.lrh_magic != LRH_MAGIC) { fprintf(stderr, "%s: invalid %s header: " "lrh_magic=%08x expected %08x\n", progname, REPLY_DATA, lrh.lrh_magic, LRH_MAGIC); goto out_close; } if (lrh.lrh_header_size != sizeof(struct lsd_reply_header)) { fprintf(stderr, "%s: invalid %s header: " "lrh_header_size=%08x expected %08x\n", progname, REPLY_DATA, lrh.lrh_header_size, (unsigned int)sizeof(struct lsd_reply_header)); goto out_close; } if (lrh.lrh_reply_size != sizeof(struct lsd_reply_data)) { fprintf(stderr, "%s: invalid %s header: " "lrh_reply_size=%08x expected %08x\n", progname, REPLY_DATA, lrh.lrh_reply_size, (unsigned int)sizeof(struct lsd_reply_data)); goto out_close; } /* walk throuh the reply data */ for (slot = 0; ; slot++) { /* read a reply data */ ret = fread(&lrd, 1, sizeof(lrd), filep); if (ret < sizeof(lrd)) { if (feof(filep)) break; fprintf(stderr, "%s: Short read (%d of %d)\n", progname, ret, (int)sizeof(lrd)); ret = -ferror(filep); goto out_close; } /* display reply data */ lrd.lrd_transno = __le64_to_cpu(lrd.lrd_transno); lrd.lrd_xid = __le64_to_cpu(lrd.lrd_xid); lrd.lrd_data = __le64_to_cpu(lrd.lrd_data); lrd.lrd_result = __le32_to_cpu(lrd.lrd_result); lrd.lrd_client_gen = __le32_to_cpu(lrd.lrd_client_gen); printf(" %lld:\n", slot); printf(" client_generation: %u\n", lrd.lrd_client_gen); printf(" last_transaction: %llu\n", lrd.lrd_transno); printf(" last_xid: %llu\n", lrd.lrd_xid); printf(" last_result: %u\n", lrd.lrd_result); printf(" last_data: %llu\n\n", lrd.lrd_data); } } out_close: if (filep != NULL) fclose(filep); out_rmdir: rmdir(tmpdir); return ret; }
int main (int argc, char *argv[]) { int i; char *pluginname = NULL; char *plugindir = NULL; char *configfile = NULL; char *objtype = NULL; OSyncError *error = NULL; if (argc < 2) usage (argv[0], 1); pluginname = argv[1]; for (i = 2; i < argc; i++) { char *arg = argv[i]; if (!strcmp (arg, "--config")) { configfile = argv[i + 1]; i++; if (!configfile) usage (argv[0], 1); } else if (!strcmp (arg, "--type")) { objtype = argv[i + 1]; i++; if (!objtype) usage (argv[0], 1); } else if (!strcmp (arg, "--plugindir")) { printf("plugindir %s\n", argv[i + 1]); plugindir = argv[i + 1]; i++; if (!plugindir) usage (argv[0], 1); } else if (!strcmp (arg, "--random")) { only_random = TRUE; } else if (!strcmp (arg, "--help")) { usage (argv[0], 0); } else { usage (argv[0], 1); } } OSyncEnv *env = osync_env_new(NULL); osync_env_set_option(env, "LOAD_GROUPS", "FALSE"); if (plugindir) osync_env_set_option(env, "PLUGINS_DIRECTORY", plugindir); if (!osync_env_initialize(env, &error)) { printf("Unable to initialize environment: %s\n", osync_error_print(&error)); osync_error_unref(&error); return 1; } char *testdir = g_strdup_printf("%s/plgtest.XXXXXX", g_get_tmp_dir()); char *result = mkdtemp(testdir); if (result == NULL) { osync_trace(TRACE_EXIT_ERROR, "unable to create temporary dir: %s", g_strerror(errno)); return 1; } OSyncGroup *group = osync_group_new(env); osync_group_set_name(group, osync_rand_str(8)); osync_group_set_configdir(group, testdir); OSyncMember *member = osync_member_new(group); char *config = NULL; int size = 0; if (configfile) { if (!osync_file_read(configfile, &config, &size, &error)) { fprintf(stderr, "Unable to read config: %s\n", osync_error_print(&error)); osync_error_unref(&error); return 1; } osync_member_set_config(member, config, size); } osync_member_set_pluginname(member, pluginname); OSyncMember *file = osync_member_new(group); localdir = g_strdup_printf("%s/plgtest.XXXXXX", g_get_tmp_dir()); result = mkdtemp(localdir); if (result == NULL) { osync_trace(TRACE_EXIT_ERROR, "unable to create temporary dir: %s", g_strerror(errno)); return 1; } config = g_strdup_printf("<config><path>%s</path><recursive>0</recursive></config>", localdir); osync_member_set_config(file, config, strlen(config) + 1); osync_member_set_pluginname(file, "file-sync"); if (!osync_group_save(group, &error)) { printf("Error while creating syncengine: %s\n", osync_error_print(&error)); osync_error_unref(&error); goto error_free_env; } if (!g_thread_supported ()) g_thread_init (NULL); OSyncEngine *engine = osengine_new(group, &error); if (!engine) { printf("Error while creating syncengine: %s\n", osync_error_print(&error)); osync_error_unref(&error); goto error_free_env; } if (!osengine_init(engine, &error)) { printf("Error while initializing syncengine: %s\n", osync_error_print(&error)); osync_error_unref(&error); goto error_free_engine; } int count = 0; if (only_random) { do { count++; printf("++++++++++++++++++++++++++++++\n"); printf("Initializing new round #%i!\n", count); if (g_random_int_range(0, 5) == 0) { int i; OSyncFormatEnv *env = osync_group_get_format_env(group); for (i = 0; i < osync_conv_num_objtypes(env); i++) { if (g_random_int_range(0, 5) == 0) { OSyncObjType *type = osync_conv_nth_objtype(env, i); osync_group_set_slow_sync(group, osync_objtype_get_name(type), TRUE); printf("Requesting slow-sync for: %s\n", osync_objtype_get_name(type)); } } osync_conv_env_free(env); } change_content(); check_sync(engine, "Random", 1); } while (g_random_int_range(0, 3) != 0); printf("Finalizing engine\n"); osengine_finalize(engine); osengine_free(engine); engine = osengine_new(group, &error); if (!engine) { printf("Error while creating syncengine: %s\n", osync_error_print(&error)); osync_error_unref(&error); goto error_free_env; } if (!osengine_init(engine, &error)) { printf("Error while initializing syncengine: %s\n", osync_error_print(&error)); osync_error_unref(&error); goto error_free_engine; } } else { register_tests(); run_all_tests(engine, file, member, objtype); } printf("\nCompleted successfully\n"); return 0; error_free_engine: osengine_free(engine); error_free_env: osync_group_free(group); osync_env_free(env); return 1; }
std::string FileUtils::create_temporary_dir(const std::string &directory) { #ifdef _WIN32 // This Win32 code is adapted from the awesome libuv library (MIT-licensed) // https://github.com/libuv/libuv/blob/v1.x/src/win/fs.c constexpr char possible[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; constexpr size_t num_chars = 62; constexpr size_t num_x = 6; constexpr char suffix[] = "\\mbpatcher-"; HCRYPTPROV h_prov; bool ret = CryptAcquireContext( &h_prov, // phProv nullptr, // pszContainer nullptr, // pszProvider PROV_RSA_FULL, // dwProvType CRYPT_VERIFYCONTEXT // dwFlags ); if (!ret) { LOGE("CryptAcquireContext() failed: %s", ec_from_win32().message().c_str()); return std::string(); } std::string new_path = directory; // Path new_path += suffix; // "\mbpatcher-" new_path.resize(new_path.size() + num_x); // Unique part char *unique = &new_path[new_path.size() - num_x]; unsigned int tries = TMP_MAX; do { uint64_t v; ret = CryptGenRandom( h_prov, // hProv sizeof(v), // dwLen reinterpret_cast<BYTE *>(&v) // pbBuffer ); if (!ret) { LOGE("CryptGenRandom() failed: %s", ec_from_win32().message().c_str()); break; } for (size_t i = 0; i < num_x; ++i) { unique[i] = possible[v % num_chars]; v /= num_chars; } // This is not particularly fast, but it'll do for now auto w_new_path = utf8_to_wcs(new_path); if (!w_new_path) { LOGE("Failed to convert UTF-8 to WCS: %s", w_new_path.error().message().c_str()); break; } ret = CreateDirectoryW( w_new_path.value().c_str(), // lpPathName nullptr // lpSecurityAttributes ); if (ret) { break; } else if (GetLastError() != ERROR_ALREADY_EXISTS) { LOGE("CreateDirectoryW() failed: %s", ec_from_win32().message().c_str()); new_path.clear(); break; } } while (--tries); bool released = CryptReleaseContext( h_prov, // hProv 0 // dwFlags ); assert(released); return new_path; #else std::string dir_template(directory); dir_template += "/mbpatcher-XXXXXX"; if (mkdtemp(&dir_template[0])) { return dir_template; } return {}; #endif }
int _alpm_runscriptlet(alpm_handle_t *handle, const char *filepath, const char *script, const char *ver, const char *oldver, int is_archive) { char arg0[64], arg1[3], cmdline[PATH_MAX]; char *argv[] = { arg0, arg1, cmdline, NULL }; char *tmpdir, *scriptfn = NULL, *scriptpath; int retval = 0; size_t len; if(_alpm_access(handle, NULL, filepath, R_OK) != 0) { _alpm_log(handle, ALPM_LOG_DEBUG, "scriptlet '%s' not found\n", filepath); return 0; } if(!is_archive && !grep(filepath, script)) { /* script not found in scriptlet file; we can only short-circuit this early * if it is an actual scriptlet file and not an archive. */ return 0; } strcpy(arg0, SCRIPTLET_SHELL); strcpy(arg1, "-c"); /* create a directory in $root/tmp/ for copying/extracting the scriptlet */ len = strlen(handle->root) + strlen("tmp/alpm_XXXXXX") + 1; MALLOC(tmpdir, len, RET_ERR(handle, ALPM_ERR_MEMORY, -1)); snprintf(tmpdir, len, "%stmp/", handle->root); if(access(tmpdir, F_OK) != 0) { _alpm_makepath_mode(tmpdir, 01777); } snprintf(tmpdir, len, "%stmp/alpm_XXXXXX", handle->root); if(mkdtemp(tmpdir) == NULL) { _alpm_log(handle, ALPM_LOG_ERROR, _("could not create temp directory\n")); free(tmpdir); return 1; } /* either extract or copy the scriptlet */ len += strlen("/.INSTALL"); MALLOC(scriptfn, len, free(tmpdir); RET_ERR(handle, ALPM_ERR_MEMORY, -1)); snprintf(scriptfn, len, "%s/.INSTALL", tmpdir); if(is_archive) { if(_alpm_unpack_single(handle, filepath, tmpdir, ".INSTALL")) { retval = 1; } } else { if(_alpm_copyfile(filepath, scriptfn)) { _alpm_log(handle, ALPM_LOG_ERROR, _("could not copy tempfile to %s (%s)\n"), scriptfn, strerror(errno)); retval = 1; } } if(retval == 1) { goto cleanup; } if(is_archive && !grep(scriptfn, script)) { /* script not found in extracted scriptlet file */ goto cleanup; } /* chop off the root so we can find the tmpdir in the chroot */ scriptpath = scriptfn + strlen(handle->root) - 1; if(oldver) { snprintf(cmdline, PATH_MAX, ". %s; %s %s %s", scriptpath, script, ver, oldver); } else { snprintf(cmdline, PATH_MAX, ". %s; %s %s", scriptpath, script, ver); } _alpm_log(handle, ALPM_LOG_DEBUG, "executing \"%s\"\n", cmdline); retval = _alpm_run_chroot(handle, SCRIPTLET_SHELL, argv); cleanup: if(scriptfn && unlink(scriptfn)) { _alpm_log(handle, ALPM_LOG_WARNING, _("could not remove %s\n"), scriptfn); } if(rmdir(tmpdir)) { _alpm_log(handle, ALPM_LOG_WARNING, _("could not remove tmpdir %s\n"), tmpdir); } free(scriptfn); free(tmpdir); return retval; }
void Import::process(std::istream &zipData) { string fileName = getFileStoragePath(saveStreamToFile(zipData)); char tempName[] = "zipXXXXXX"; mkdtemp(tempName); string dirName = tempName; string command = "unzip " + fileName + " -d " + dirName; system(command.c_str()); DIR *dir = opendir((dirName + "/.").c_str()); struct dirent *d; map<string, pair<vector<string>, vector<string>>> data; while ((d = readdir(dir)) != NULL) { string taskName = d->d_name; if (taskName == ".") continue; if (taskName == "..") continue; DIR *dir2 = opendir((dirName + "/" + taskName + "/.").c_str()); struct dirent *d2; vector<string> inputData, outputData; while ((d2 = readdir(dir2)) != NULL) { string fileName = d2->d_name; if (fileName == ".") continue; if (fileName == "..") continue; if (fileName == "task.nfo") continue; if (fileName.find(".in") != string::npos) inputData.push_back(fileName); if (fileName.find(".IN") != string::npos) inputData.push_back(fileName); if (fileName.find(".out") != string::npos) outputData.push_back(fileName); if (fileName.find(".OUT") != string::npos) outputData.push_back(fileName); } sort(inputData.begin(), inputData.end()); sort(outputData.begin(), outputData.end()); while (outputData.size() < inputData.size()) outputData.push_back(""); data[taskName] = make_pair(inputData, outputData); } for (auto x : data) { string taskName = x.first; tasks.push_back(taskName); for (size_t i = 0; i < data[x.first].first.size(); i++) { string newInputName = data[x.first].first[i]; string newOutputName = data[x.first].second[i]; FileSave inputSaver, outputSaver; inputSaver.writeFileContents(dirName + "/" + x.first + "/" + newInputName); if (newOutputName != "") { outputSaver.writeFileContents(dirName + "/" + x.first + "/" + newOutputName); } string inputHash = inputSaver.save(); string outputHash = outputSaver.save(); inputs[taskName].push_back(make_pair(inputHash, newInputName)); outputs[taskName].push_back(make_pair(outputHash, newOutputName)); } std::ifstream info; info.open(dirName + "/" + x.first + "/task.nfo"); if (info.is_open()) { while (true) { string header; info >> header; if (!info.good() || header != "group") break; int points; info >> points; vector<string> list; while (true) { string prefix; info >> prefix; if (prefix == "end") break; list.push_back(prefix); } groups[taskName].push_back(make_pair(points, list)); } } } command = "rm -rf " + dirName; system(command.c_str()); }
void PhraseDictionaryFuzzyMatch::InitializeForInput(InputType const& inputSentence) { #ifdef WIN32 boost::filesystem::path _mypath = boost::filesystem::unique_path(); boost::filesystem::create_directories(_mypath); string dirNameStr = boost::filesystem::canonical(_mypath).string(); #else char dirName[] = "/tmp/moses.XXXXXX"; char *temp = mkdtemp(dirName); CHECK(temp); string dirNameStr(dirName); #endif string inFileName(dirNameStr + "/in"); ofstream inFile(inFileName.c_str()); for (size_t i = 1; i < inputSentence.GetSize() - 1; ++i) { inFile << inputSentence.GetWord(i); } inFile << endl; inFile.close(); long translationId = inputSentence.GetTranslationId(); string ptFileName = m_FuzzyMatchWrapper->Extract(translationId, dirNameStr); // populate with rules for this sentence PhraseDictionaryNodeSCFG &rootNode = m_collection[translationId]; FormatType format = MosesFormat; // data from file InputFileStream inStream(ptFileName); // copied from class LoaderStandard PrintUserTime("Start loading fuzzy-match phrase model"); const StaticData &staticData = StaticData::Instance(); const std::string& factorDelimiter = staticData.GetFactorDelimiter(); string lineOrig; size_t count = 0; while(getline(inStream, lineOrig)) { const string *line; if (format == HieroFormat) { // reformat line assert(false); //line = ReformatHieroRule(lineOrig); } else { // do nothing to format of line line = &lineOrig; } vector<string> tokens; vector<float> scoreVector; TokenizeMultiCharSeparator(tokens, *line , "|||" ); if (tokens.size() != 4 && tokens.size() != 5) { stringstream strme; strme << "Syntax error at " << ptFileName << ":" << count; UserMessage::Add(strme.str()); abort(); } const string &sourcePhraseString = tokens[0] , &targetPhraseString = tokens[1] , &scoreString = tokens[2] , &alignString = tokens[3]; bool isLHSEmpty = (sourcePhraseString.find_first_not_of(" \t", 0) == string::npos); if (isLHSEmpty && !staticData.IsWordDeletionEnabled()) { TRACE_ERR( ptFileName << ":" << count << ": pt entry contains empty target, skipping\n"); continue; } Tokenize<float>(scoreVector, scoreString); const size_t numScoreComponents = GetFeature()->GetNumScoreComponents(); if (scoreVector.size() != numScoreComponents) { stringstream strme; strme << "Size of scoreVector != number (" << scoreVector.size() << "!=" << numScoreComponents << ") of score components on line " << count; UserMessage::Add(strme.str()); abort(); } CHECK(scoreVector.size() == numScoreComponents); // parse source & find pt node // constituent labels Word sourceLHS, targetLHS; // source Phrase sourcePhrase( 0); sourcePhrase.CreateFromStringNewFormat(Input, *m_input, sourcePhraseString, factorDelimiter, sourceLHS); // create target phrase obj TargetPhrase *targetPhrase = new TargetPhrase(); targetPhrase->CreateFromStringNewFormat(Output, *m_output, targetPhraseString, factorDelimiter, targetLHS); // rest of target phrase targetPhrase->SetAlignmentInfo(alignString); targetPhrase->SetTargetLHS(targetLHS); //targetPhrase->SetDebugOutput(string("New Format pt ") + line); // component score, for n-best output std::transform(scoreVector.begin(),scoreVector.end(),scoreVector.begin(),TransformScore); std::transform(scoreVector.begin(),scoreVector.end(),scoreVector.begin(),FloorScore); targetPhrase->SetScoreChart(GetFeature(), scoreVector, *m_weight, *m_languageModels, m_wpProducer); TargetPhraseCollection &phraseColl = GetOrCreateTargetPhraseCollection(rootNode, sourcePhrase, *targetPhrase, sourceLHS); phraseColl.Add(targetPhrase); count++; if (format == HieroFormat) { // reformat line delete line; } else { // do nothing } } // sort and prune each target phrase collection SortAndPrune(rootNode); //removedirectoryrecursively(dirName); }
char* generate_fonts (const JBDATA * data, const struct mapping *maps, int num_fonts, char *dir) { int dirnamelen = 0; char *dirname = NULL; if (dir == NULL) { /* Create a file in the system temp dir (usually /tmp) */ /* This may not be portable to Windows */ char suffix[] = "smoothscan_XXXXXX"; /* Use the value of environmental var TMPDIR if it is set */ char *tmpdir = getenv ("TMPDIR"); if (tmpdir == NULL) { /* Load the default temp directory */ tmpdir = P_tmpdir; } int tmpdirlen = strlen (tmpdir); int suffixlen = strlen (suffix); dirnamelen = tmpdirlen + suffixlen + 1; dirname = malloc_guarded (dirnamelen + 1); sprintf (dirname, "%s/%s", tmpdir, suffix); if (mkdtemp (dirname) == NULL) { error_quit ("Failed to create main temp directory."); } } else { if (mkdir (dir, 0700) == -1) { if (errno != EEXIST) { error_quit ("Couldn't make tmpdir."); } } dirname = dir; dirnamelen = strlen (dir); } int i; PIXA *templates = pixaCreateFromPix (data->pix, data->nclass, data->latticew, data->latticeh); if (templates == NULL) { error_quit ("Could not create templates from JBDATA."); } /* Create a temp dir for each font */ char **fontdirnames = malloc_guarded (num_fonts * sizeof (char *)); int *fontdirlens = malloc_guarded (num_fonts * sizeof (int *)); for (i = 0; i < num_fonts; i++) { /* 1 for / 8 for %08d */ fontdirlens[i] = dirnamelen + 1 + 8; fontdirnames[i] = malloc_guarded (fontdirlens[i] + 1); sprintf (fontdirnames[i], "%s/%08d", dirname, i); if (mkdir (fontdirnames[i], 0700) == -1) { error_quit ("Failed to create font temp directory."); } } for (i = 0; i < templates->n; i++) { l_int32 iclass; l_int32 x; l_int32 y; numaGetIValue (data->naclass, i, &iclass); ptaGetIPt (data->ptaul, i, &x, &y); PIX *pix_clone = pixaGetPix (templates, i, L_CLONE); /* the template */ double wp1 = pixGetWidth (pix_clone); double hp1 = pixGetHeight (pix_clone); PIX *pix_padded = pixAddBorderGeneral (pix_clone, 0, data->latticew - wp1, 0, data->latticeh - hp1, 0); if (pix_padded == NULL) { error_quit ("Failed to add border to image."); } int fontn = maps[i].font_num; int code_point = maps[i].code_point; /* 1 for '/', 3 for %03d, 4 for '.png' */ int filenamelen = fontdirlens[fontn] + 1 + 3 + 4; char *filename = malloc_guarded (filenamelen + 1); sprintf (filename, "%s/%03d.png", fontdirnames[fontn], code_point); if (pixWrite (filename, pix_padded, IFF_PNG) == 1) { printf ("pixWrite failed to write %s.\n", filename); error_quit ("Could not write to file."); } pixDestroy (&pix_clone); pixDestroy (&pix_padded); free (filename); } pixaDestroy (&templates); /* This part probably won't port over to Windows as well */ /* TODO: parallelize this */ for (i = 0; i < num_fonts; i++) { /* 1 for '/', 8 for %08d, 4 for '.ttf' */ int fontnamelen = dirnamelen + 1 + 8 + 4; char *fontnamestr = malloc_guarded (fontnamelen + 1); sprintf (fontnamestr, "%s/%08d.ttf", dirname, i); create_font_from_dir (fontdirnames[i], fontnamestr, data->latticeh, data->latticew, i); free (fontnamestr); } /* clean up */ for (i = 0; i < num_fonts; i++) { free (fontdirnames[i]); } free (fontdirnames); free (fontdirlens); return dirname; }
void *rszshm_mk(struct rszshm *r, size_t flen, const char *fname, struct rszshm_scan scan) { long pgsz = sysconf(_SC_PAGE_SIZE); int i, errno_; char *m, *tgt, *p = NULL; if (!r || flen == 0 || scan.len < flen + sizeof(*r->hdr) || !scan.start || scan.len == 0 || scan.hop == 0 || scan.iter == 0 || (fname && strnlen(fname, RSZSHM_PATH_MAX) == RSZSHM_PATH_MAX)) { errno = EINVAL; return NULL; } *r = (typeof(*r)) { -1, 0, "", NULL, NULL }; strcpy(r->fname, fname ? fname : RSZSHM_DFLT_FNAME); flen = pgup(flen + sizeof(*r->hdr), pgsz); scan.len = pgup(scan.len, pgsz); for (i = 1, tgt = scan.start; i <= scan.iter; i++) { m = mmap(tgt, scan.len, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON|MAP_NORESERVE, -1, 0); if (m == MAP_FAILED) return NULL; if (m == tgt) break; munmap(m, scan.len); m = NULL; tgt += (i % 2 == 0 ? 1 : -1) * i * scan.hop; } if (!m) { errno = ENOSPC; return NULL; } if ((p = strstr(r->fname, "XXXXXX/")) != NULL) { p += 6; *p = '\0'; if (!mkdtemp(r->fname)) goto err; *p = '/'; } if ((r->fd = open(r->fname, O_CREAT|O_EXCL|O_RDWR, p ? 0600 : 0666)) == -1) goto err; if (ftruncate(r->fd, flen) == -1) goto err; if (mmap(m, flen, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, r->fd, 0) == MAP_FAILED) goto err; *(r->hdr = (typeof(r->hdr)) m) = (typeof(*r->hdr)) { flen, scan.len, m }; if (msync(m, sizeof(*r->hdr), MS_SYNC) == -1) goto err; r->flen = flen; r->cap = flen - sizeof(*r->hdr); r->dat = m + sizeof(*r->hdr); return r->dat; err: errno_ = errno; if (m && m != MAP_FAILED) munmap(m, scan.len); if (r->fd != -1) { close(r->fd); unlink(r->fname); } if (p) { *p = '\0'; rmdir(r->fname); *p = '/'; } errno = errno_; return NULL; }
int setup_machine_directory(uint64_t size, sd_bus_error *error) { _cleanup_release_lock_file_ LockFile lock_file = LOCK_FILE_INIT; struct loop_info64 info = { .lo_flags = LO_FLAGS_AUTOCLEAR, }; _cleanup_close_ int fd = -1, control = -1, loop = -1; _cleanup_free_ char* loopdev = NULL; char tmpdir[] = "/tmp/import-mount.XXXXXX", *mntdir = NULL; bool tmpdir_made = false, mntdir_made = false, mntdir_mounted = false; char buf[FORMAT_BYTES_MAX]; int r, nr = -1; /* btrfs cannot handle file systems < 16M, hence use this as minimum */ if (size == (uint64_t) -1) size = VAR_LIB_MACHINES_SIZE_START; else if (size < 16*1024*1024) size = 16*1024*1024; /* Make sure we only set the directory up once at a time */ r = make_lock_file("/run/systemd/machines.lock", LOCK_EX, &lock_file); if (r < 0) return r; r = check_btrfs(); if (r < 0) return sd_bus_error_set_errnof(error, r, "Failed to determine whether /var/lib/machines is located on btrfs: %m"); if (r > 0) { (void) btrfs_subvol_make_label("/var/lib/machines"); r = btrfs_quota_enable("/var/lib/machines", true); if (r < 0) log_warning_errno(r, "Failed to enable quota, ignoring: %m"); return 0; } if (path_is_mount_point("/var/lib/machines", true) > 0 || dir_is_empty("/var/lib/machines") == 0) return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "/var/lib/machines is not a btrfs file system. Operation is not supported on legacy file systems."); fd = setup_machine_raw(size, error); if (fd < 0) return fd; control = open("/dev/loop-control", O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK); if (control < 0) return sd_bus_error_set_errnof(error, errno, "Failed to open /dev/loop-control: %m"); nr = ioctl(control, LOOP_CTL_GET_FREE); if (nr < 0) return sd_bus_error_set_errnof(error, errno, "Failed to allocate loop device: %m"); if (asprintf(&loopdev, "/dev/loop%i", nr) < 0) { r = -ENOMEM; goto fail; } loop = open(loopdev, O_CLOEXEC|O_RDWR|O_NOCTTY|O_NONBLOCK); if (loop < 0) { r = sd_bus_error_set_errnof(error, errno, "Failed to open loopback device: %m"); goto fail; } if (ioctl(loop, LOOP_SET_FD, fd) < 0) { r = sd_bus_error_set_errnof(error, errno, "Failed to bind loopback device: %m"); goto fail; } if (ioctl(loop, LOOP_SET_STATUS64, &info) < 0) { r = sd_bus_error_set_errnof(error, errno, "Failed to enable auto-clear for loopback device: %m"); goto fail; } /* We need to make sure the new /var/lib/machines directory * has an access mode of 0700 at the time it is first made * available. mkfs will create it with 0755 however. Hence, * let's mount the directory into an inaccessible directory * below /tmp first, fix the access mode, and move it to the * public place then. */ if (!mkdtemp(tmpdir)) { r = sd_bus_error_set_errnof(error, errno, "Failed to create temporary mount parent directory: %m"); goto fail; } tmpdir_made = true; mntdir = strjoina(tmpdir, "/mnt"); if (mkdir(mntdir, 0700) < 0) { r = sd_bus_error_set_errnof(error, errno, "Failed to create temporary mount directory: %m"); goto fail; } mntdir_made = true; if (mount(loopdev, mntdir, "btrfs", 0, NULL) < 0) { r = sd_bus_error_set_errnof(error, errno, "Failed to mount loopback device: %m"); goto fail; } mntdir_mounted = true; r = btrfs_quota_enable(mntdir, true); if (r < 0) log_warning_errno(r, "Failed to enable quota, ignoring: %m"); if (chmod(mntdir, 0700) < 0) { r = sd_bus_error_set_errnof(error, errno, "Failed to fix owner: %m"); goto fail; } (void) mkdir_p_label("/var/lib/machines", 0700); if (mount(mntdir, "/var/lib/machines", NULL, MS_BIND, NULL) < 0) { r = sd_bus_error_set_errnof(error, errno, "Failed to mount directory into right place: %m"); goto fail; } (void) syncfs(fd); log_info("Set up /var/lib/machines as btrfs loopback file system of size %s mounted on /var/lib/machines.raw.", format_bytes(buf, sizeof(buf), size)); (void) umount2(mntdir, MNT_DETACH); (void) rmdir(mntdir); (void) rmdir(tmpdir); return 0; fail: if (mntdir_mounted) (void) umount2(mntdir, MNT_DETACH); if (mntdir_made) (void) rmdir(mntdir); if (tmpdir_made) (void) rmdir(tmpdir); if (loop >= 0) { (void) ioctl(loop, LOOP_CLR_FD); loop = safe_close(loop); } if (control >= 0 && nr >= 0) (void) ioctl(control, LOOP_CTL_REMOVE, nr); return r; }
static void test_chase_symlinks(void) { _cleanup_free_ char *result = NULL; char temp[] = "/tmp/test-chase.XXXXXX"; const char *top, *p, *q; int r; assert_se(mkdtemp(temp)); top = strjoina(temp, "/top"); assert_se(mkdir(top, 0700) >= 0); p = strjoina(top, "/dot"); assert_se(symlink(".", p) >= 0); p = strjoina(top, "/dotdot"); assert_se(symlink("..", p) >= 0); p = strjoina(top, "/dotdota"); assert_se(symlink("../a", p) >= 0); p = strjoina(temp, "/a"); assert_se(symlink("b", p) >= 0); p = strjoina(temp, "/b"); assert_se(symlink("/usr", p) >= 0); p = strjoina(temp, "/start"); assert_se(symlink("top/dot/dotdota", p) >= 0); /* Paths that use symlinks underneath the "root" */ r = chase_symlinks(p, NULL, 0, &result); assert_se(r > 0); assert_se(path_equal(result, "/usr")); result = mfree(result); r = chase_symlinks(p, temp, 0, &result); assert_se(r == -ENOENT); q = strjoina(temp, "/usr"); r = chase_symlinks(p, temp, CHASE_NONEXISTENT, &result); assert_se(r == 0); assert_se(path_equal(result, q)); assert_se(mkdir(q, 0700) >= 0); result = mfree(result); r = chase_symlinks(p, temp, 0, &result); assert_se(r > 0); assert_se(path_equal(result, q)); p = strjoina(temp, "/slash"); assert_se(symlink("/", p) >= 0); result = mfree(result); r = chase_symlinks(p, NULL, 0, &result); assert_se(r > 0); assert_se(path_equal(result, "/")); result = mfree(result); r = chase_symlinks(p, temp, 0, &result); assert_se(r > 0); assert_se(path_equal(result, temp)); /* Paths that would "escape" outside of the "root" */ p = strjoina(temp, "/6dots"); assert_se(symlink("../../..", p) >= 0); result = mfree(result); r = chase_symlinks(p, temp, 0, &result); assert_se(r > 0 && path_equal(result, temp)); p = strjoina(temp, "/6dotsusr"); assert_se(symlink("../../../usr", p) >= 0); result = mfree(result); r = chase_symlinks(p, temp, 0, &result); assert_se(r > 0 && path_equal(result, q)); p = strjoina(temp, "/top/8dotsusr"); assert_se(symlink("../../../../usr", p) >= 0); result = mfree(result); r = chase_symlinks(p, temp, 0, &result); assert_se(r > 0 && path_equal(result, q)); /* Paths that contain repeated slashes */ p = strjoina(temp, "/slashslash"); assert_se(symlink("///usr///", p) >= 0); result = mfree(result); r = chase_symlinks(p, NULL, 0, &result); assert_se(r > 0); assert_se(path_equal(result, "/usr")); result = mfree(result); r = chase_symlinks(p, temp, 0, &result); assert_se(r > 0); assert_se(path_equal(result, q)); /* Paths using . */ result = mfree(result); r = chase_symlinks("/etc/./.././", NULL, 0, &result); assert_se(r > 0); assert_se(path_equal(result, "/")); result = mfree(result); r = chase_symlinks("/etc/./.././", "/etc", 0, &result); assert_se(r > 0 && path_equal(result, "/etc")); result = mfree(result); r = chase_symlinks("/etc/machine-id/foo", NULL, 0, &result); assert_se(r == -ENOTDIR); /* Path that loops back to self */ result = mfree(result); p = strjoina(temp, "/recursive-symlink"); assert_se(symlink("recursive-symlink", p) >= 0); r = chase_symlinks(p, NULL, 0, &result); assert_se(r == -ELOOP); /* Path which doesn't exist */ p = strjoina(temp, "/idontexist"); r = chase_symlinks(p, NULL, 0, &result); assert_se(r == -ENOENT); r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result); assert_se(r == 0); assert_se(path_equal(result, p)); result = mfree(result); p = strjoina(temp, "/idontexist/meneither"); r = chase_symlinks(p, NULL, 0, &result); assert_se(r == -ENOENT); r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result); assert_se(r == 0); assert_se(path_equal(result, p)); result = mfree(result); /* Path which doesn't exist, but contains weird stuff */ p = strjoina(temp, "/idontexist/.."); r = chase_symlinks(p, NULL, 0, &result); assert_se(r == -ENOENT); r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result); assert_se(r == -ENOENT); p = strjoina(temp, "/target"); q = strjoina(temp, "/top"); assert_se(symlink(q, p) >= 0); p = strjoina(temp, "/target/idontexist"); r = chase_symlinks(p, NULL, 0, &result); assert_se(r == -ENOENT); assert_se(rm_rf(temp, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0); }
static void test_non_empty(void) { dual_timestamp ts; JournalFile *f; struct iovec iovec; static const char test[] = "TEST1=1", test2[] = "TEST2=2"; Object *o; uint64_t p; char t[] = "/tmp/journal-XXXXXX"; log_set_max_level(LOG_DEBUG); assert_se(mkdtemp(t)); assert_se(chdir(t) >= 0); assert_se(journal_file_open("test.journal", O_RDWR|O_CREAT, 0666, true, true, NULL, NULL, NULL, &f) == 0); dual_timestamp_get(&ts); iovec.iov_base = (void*) test; iovec.iov_len = strlen(test); assert_se(journal_file_append_entry(f, &ts, &iovec, 1, NULL, NULL, NULL) == 0); iovec.iov_base = (void*) test2; iovec.iov_len = strlen(test2); assert_se(journal_file_append_entry(f, &ts, &iovec, 1, NULL, NULL, NULL) == 0); iovec.iov_base = (void*) test; iovec.iov_len = strlen(test); assert_se(journal_file_append_entry(f, &ts, &iovec, 1, NULL, NULL, NULL) == 0); #ifdef HAVE_GCRYPT journal_file_append_tag(f); #endif journal_file_dump(f); assert_se(journal_file_next_entry(f, 0, DIRECTION_DOWN, &o, &p) == 1); assert_se(le64toh(o->entry.seqnum) == 1); assert_se(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p) == 1); assert_se(le64toh(o->entry.seqnum) == 2); assert_se(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p) == 1); assert_se(le64toh(o->entry.seqnum) == 3); assert_se(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p) == 0); assert_se(journal_file_next_entry(f, 0, DIRECTION_DOWN, &o, &p) == 1); assert_se(le64toh(o->entry.seqnum) == 1); assert_se(journal_file_find_data_object(f, test, strlen(test), NULL, &p) == 1); assert_se(journal_file_next_entry_for_data(f, NULL, 0, p, DIRECTION_DOWN, &o, NULL) == 1); assert_se(le64toh(o->entry.seqnum) == 1); assert_se(journal_file_next_entry_for_data(f, NULL, 0, p, DIRECTION_UP, &o, NULL) == 1); assert_se(le64toh(o->entry.seqnum) == 3); assert_se(journal_file_find_data_object(f, test2, strlen(test2), NULL, &p) == 1); assert_se(journal_file_next_entry_for_data(f, NULL, 0, p, DIRECTION_UP, &o, NULL) == 1); assert_se(le64toh(o->entry.seqnum) == 2); assert_se(journal_file_next_entry_for_data(f, NULL, 0, p, DIRECTION_DOWN, &o, NULL) == 1); assert_se(le64toh(o->entry.seqnum) == 2); assert_se(journal_file_find_data_object(f, "quux", 4, NULL, &p) == 0); assert_se(journal_file_move_to_entry_by_seqnum(f, 1, DIRECTION_DOWN, &o, NULL) == 1); assert_se(le64toh(o->entry.seqnum) == 1); assert_se(journal_file_move_to_entry_by_seqnum(f, 3, DIRECTION_DOWN, &o, NULL) == 1); assert_se(le64toh(o->entry.seqnum) == 3); assert_se(journal_file_move_to_entry_by_seqnum(f, 2, DIRECTION_DOWN, &o, NULL) == 1); assert_se(le64toh(o->entry.seqnum) == 2); assert_se(journal_file_move_to_entry_by_seqnum(f, 10, DIRECTION_DOWN, &o, NULL) == 0); journal_file_rotate(&f, true, true); journal_file_rotate(&f, true, true); journal_file_close(f); log_info("Done..."); if (arg_keep) log_info("Not removing %s", t); else { journal_directory_vacuum(".", 3000000, 0, 0, NULL, true); assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0); } puts("------------------------------------------------------------"); }
int main() { int inputPipe; char buffer[BUFFER_LEN]; char mktemp_filename[PATH_MAX]; char mktemp_dir[PATH_MAX]; int ret; int terminalPid; TerminalList * termlist = lst_new(); pthread_t threadMonitor; char *args[N_ARGS]; if (signal(SIGINT, handleSIGINT)) { fprintf(stderr, "Could not set sigint handler!\n"); exit(EXIT_FAILURE); } if (pthread_mutex_init(&mutexRunningProcesses, NULL)) { fprintf(stderr, "Could not create runningProcesses mutex\n"); exit(EXIT_FAILURE); } if (pthread_cond_init(&condRunningProcesses, NULL)) { fprintf(stderr, "Could not create runningProcesses cond\n"); exit(EXIT_FAILURE); } if (pthread_cond_init(&condFreeSlots, NULL)) { fprintf(stderr, "Could not create FreeSlots cond\n"); exit(EXIT_FAILURE); } strcpy(mktemp_dir, MKTEMP_TEMPLATE); TESTTRUE(mkdtemp(mktemp_dir)!=NULL, "Erro na criação do diretorio temporário (" _AT_ ")\n"); strncpy(mktemp_filename, mktemp_dir, PATH_MAX); strncpy(mktemp_filename+strlen(mktemp_filename), "/" INPUT_FILE, PATH_MAX-strlen(mktemp_filename)); fprintf(stdin, "Ficheiro de input: '%s'\n", mktemp_filename); if (mkfifo(mktemp_filename, 0660) <0) { fprintf(stderr, "Could not create fifo %s\n", mktemp_filename); exit(EXIT_FAILURE); } printf("A abrir o pipe %s para leitura...\n", mktemp_filename); if ((inputPipe = open(mktemp_filename, O_RDONLY)) < 0) { fprintf(stderr, "Could not create fifo " INPUT_FILE "\n"); exit(EXIT_FAILURE); } printf("A abrir o pipe %s para escrita...\n", mktemp_filename); if ((outPipe = open(mktemp_filename, O_WRONLY|O_NONBLOCK)) < 0) { fprintf(stderr, "Erro ao abrir o ficheiro de output" INPUT_FILE "\n"); exit(EXIT_FAILURE); } initProcessList(); if(pthread_create(&threadMonitor, 0,processMonitor, NULL)!= 0) { printf("Erro na criação da tarefa\n"); exit(EXIT_FAILURE); } while(1) { if (exitCalled) break; if (readFromPipe(inputPipe, buffer, &terminalPid, termlist)!=0) continue; printf("Comando: %s\n", buffer); ret = readLineArguments(args, N_ARGS, buffer, BUFFER_LEN); if (!ret) continue; processesWaitingToRun++; newProcess(args, terminalPid); } //Mata todos os processos de terminal lst_destroy(termlist); C_SIGNAL(&condRunningProcesses); pthread_join(threadMonitor, NULL); //The following function is called after all threads have joined, therefore there aren't used any mutexes exitParShell(); endProcessList(); pthread_mutex_destroy(&mutexRunningProcesses); pthread_cond_destroy(&condRunningProcesses); pthread_cond_destroy(&condFreeSlots); close(inputPipe); //aqui nao faz sentido testar o return destas funcoes close(outPipe); //aqui nao faz sentido testar o return destas funcoes unlink(INPUT_FILE); //aqui nao faz sentido testar o return destas funcoes return EXIT_SUCCESS; }
static void test_egd_success(void *arg) { int pipefds[2] = {-1,-1}; struct sockaddr_un sun; char dir[128] = "/tmp/otterylite_test_XXXXXX"; char fname[128] = {0}; int listener = -1; pid_t pid; int r, exitstatus=0; u8 buf[64]; unsigned flags; (void)arg; tt_assert(mkdtemp(dir) != NULL); tt_int_op(-1, ==, ottery_egd_socklen); tt_int_op(-1, ==, OTTERY_PUBLIC_FN(set_egd_address)((struct sockaddr*)&sun, 16384)); tt_assert(strlen(dir) < 128 - 32); snprintf(fname, sizeof(fname), "%s/fifo", dir); tt_int_op(strlen(fname), <, sizeof(sun.sun_path)); tt_int_op(-2, ==, ottery_getentropy_egd(buf, &flags)); /* not turned on. */ memset(&sun, 0, sizeof(sun)); sun.sun_family = -1; /* Bad family */ tt_int_op(0, ==, OTTERY_PUBLIC_FN(set_egd_address)((struct sockaddr*)&sun, sizeof(sun))); tt_int_op(-1, ==, ottery_getentropy_egd(buf, &flags)); /* bad family */ sun.sun_family = AF_UNIX; memcpy(sun.sun_path, fname, strlen(fname)+1); listener = socket(AF_UNIX, SOCK_STREAM, 0); tt_int_op(listener, >=, 0); tt_int_op(0, ==, pipe(pipefds)); tt_int_op(0, ==, OTTERY_PUBLIC_FN(set_egd_address)((struct sockaddr*)&sun, sizeof(sun))); tt_int_op(sizeof(sun), ==, ottery_egd_socklen); tt_int_op(-1, ==, ottery_getentropy_egd(buf, &flags)); /* nobody listening yet */ tt_int_op(bind(listener, (struct sockaddr*)&sun, sizeof(sun)), ==, 0); tt_int_op(listen(listener, 16), ==, 0); if ((pid = fork())) { /* parent */ close(listener); close(pipefds[1]); } else { /* child */ close(pipefds[0]); run_egd_server(listener, pipefds[1]); exit(1); } memset(buf, 0, sizeof(buf)); r = ottery_getentropy_egd(buf, &flags); tt_int_op(r, ==, ENTROPY_CHUNK); tt_assert(iszero(buf + ENTROPY_CHUNK, sizeof(buf) - ENTROPY_CHUNK)); tt_assert(! iszero(buf, ENTROPY_CHUNK)); tt_mem_op(buf, ==, notsorandom, ENTROPY_CHUNK); r = (int)read(pipefds[0], buf, 1); tt_int_op(r, ==, 1); waitpid(pid, &exitstatus, 0); tt_int_op(exitstatus, ==, 0); tt_int_op(buf[0], ==, 'Y'); tt_int_op(0, ==, OTTERY_PUBLIC_FN(set_egd_address)(NULL, 0)); tt_int_op(-1, ==, ottery_egd_socklen); end: if (pipefds[0] >= 0) close(pipefds[0]); if (pipefds[1] >= 1) close(pipefds[1]); if (*fname) unlink(fname); rmdir(dir); }
static struct ref *get_refs_via_rsync(struct transport *transport, int for_push) { struct strbuf buf = STRBUF_INIT, temp_dir = STRBUF_INIT; struct ref dummy = {NULL}, *tail = &dummy; struct child_process rsync = CHILD_PROCESS_INIT; const char *args[5]; int temp_dir_len; if (for_push) return NULL; /* copy the refs to the temporary directory */ strbuf_addstr(&temp_dir, git_path("rsync-refs-XXXXXX")); if (!mkdtemp(temp_dir.buf)) die_errno ("Could not make temporary directory"); temp_dir_len = temp_dir.len; strbuf_addstr(&buf, rsync_url(transport->url)); strbuf_addstr(&buf, "/refs"); rsync.argv = args; rsync.stdout_to_stderr = 1; args[0] = "rsync"; args[1] = (transport->verbose > 1) ? "-rv" : "-r"; args[2] = buf.buf; args[3] = temp_dir.buf; args[4] = NULL; if (run_command(&rsync)) die ("Could not run rsync to get refs"); strbuf_reset(&buf); strbuf_addstr(&buf, rsync_url(transport->url)); strbuf_addstr(&buf, "/packed-refs"); args[2] = buf.buf; if (run_command(&rsync)) die ("Could not run rsync to get refs"); /* read the copied refs */ strbuf_addstr(&temp_dir, "/refs"); read_loose_refs(&temp_dir, temp_dir_len + 1, &tail); strbuf_setlen(&temp_dir, temp_dir_len); tail = &dummy; strbuf_addstr(&temp_dir, "/packed-refs"); insert_packed_refs(temp_dir.buf, &tail); strbuf_setlen(&temp_dir, temp_dir_len); if (remove_dir_recursively(&temp_dir, 0)) warning ("Error removing temporary directory %s.", temp_dir.buf); strbuf_release(&buf); strbuf_release(&temp_dir); return dummy.next; }
void PhraseDictionaryFuzzyMatch::InitializeForInput(ttasksptr const& ttask) { InputType const& inputSentence = *ttask->GetSource(); #if defined __MINGW32__ char dirName[] = "moses.XXXXXX"; #else char dirName[] = "/tmp/moses.XXXXXX"; #endif // defined char *temp = mkdtemp(dirName); UTIL_THROW_IF2(temp == NULL, "Couldn't create temporary directory " << dirName); string dirNameStr(dirName); string inFileName(dirNameStr + "/in"); ofstream inFile(inFileName.c_str()); for (size_t i = 1; i < inputSentence.GetSize() - 1; ++i) { inFile << inputSentence.GetWord(i); } inFile << endl; inFile.close(); long translationId = inputSentence.GetTranslationId(); string ptFileName = m_FuzzyMatchWrapper->Extract(translationId, dirNameStr); // populate with rules for this sentence PhraseDictionaryNodeMemory &rootNode = m_collection[translationId]; FormatType format = MosesFormat; // data from file InputFileStream inStream(ptFileName); // copied from class LoaderStandard PrintUserTime("Start loading fuzzy-match phrase model"); const StaticData &staticData = StaticData::Instance(); string lineOrig; size_t count = 0; while(getline(inStream, lineOrig)) { const string *line; if (format == HieroFormat) { // reformat line UTIL_THROW(util::Exception, "Cannot be Hiero format"); //line = ReformatHieroRule(lineOrig); } else { // do nothing to format of line line = &lineOrig; } vector<string> tokens; vector<float> scoreVector; TokenizeMultiCharSeparator(tokens, *line , "|||" ); if (tokens.size() != 4 && tokens.size() != 5) { UTIL_THROW2("Syntax error at " << ptFileName << ":" << count); } const string &sourcePhraseString = tokens[0] , &targetPhraseString = tokens[1] , &scoreString = tokens[2] , &alignString = tokens[3]; bool isLHSEmpty = (sourcePhraseString.find_first_not_of(" \t", 0) == string::npos); if (isLHSEmpty && !staticData.IsWordDeletionEnabled()) { TRACE_ERR( ptFileName << ":" << count << ": pt entry contains empty target, skipping\n"); continue; } Tokenize<float>(scoreVector, scoreString); const size_t numScoreComponents = GetNumScoreComponents(); if (scoreVector.size() != numScoreComponents) { UTIL_THROW2("Size of scoreVector != number (" << scoreVector.size() << "!=" << numScoreComponents << ") of score components on line " << count); } UTIL_THROW_IF2(scoreVector.size() != numScoreComponents, "Number of scores incorrectly specified"); // parse source & find pt node // constituent labels Word *sourceLHS; Word *targetLHS; // source Phrase sourcePhrase( 0); sourcePhrase.CreateFromString(Input, m_input, sourcePhraseString, &sourceLHS); // create target phrase obj TargetPhrase *targetPhrase = new TargetPhrase(this); targetPhrase->CreateFromString(Output, m_output, targetPhraseString, &targetLHS); // rest of target phrase targetPhrase->SetAlignmentInfo(alignString); targetPhrase->SetTargetLHS(targetLHS); //targetPhrase->SetDebugOutput(string("New Format pt ") + line); // component score, for n-best output std::transform(scoreVector.begin(),scoreVector.end(),scoreVector.begin(),TransformScore); std::transform(scoreVector.begin(),scoreVector.end(),scoreVector.begin(),FloorScore); targetPhrase->GetScoreBreakdown().Assign(this, scoreVector); targetPhrase->EvaluateInIsolation(sourcePhrase, GetFeaturesToApply()); TargetPhraseCollection::shared_ptr phraseColl = GetOrCreateTargetPhraseCollection(rootNode, sourcePhrase, *targetPhrase, sourceLHS); phraseColl->Add(targetPhrase); count++; if (format == HieroFormat) { // reformat line delete line; } else { // do nothing } } // sort and prune each target phrase collection SortAndPrune(rootNode); //removedirectoryrecursively(dirName); }
static int rsync_transport_push(struct transport *transport, int refspec_nr, const char **refspec, int flags) { struct strbuf buf = STRBUF_INIT, temp_dir = STRBUF_INIT; int result = 0, i; struct child_process rsync = CHILD_PROCESS_INIT; const char *args[10]; if (flags & TRANSPORT_PUSH_MIRROR) return error("rsync transport does not support mirror mode"); /* first push the objects */ strbuf_addstr(&buf, rsync_url(transport->url)); strbuf_addch(&buf, '/'); rsync.argv = args; rsync.stdout_to_stderr = 1; i = 0; args[i++] = "rsync"; args[i++] = "-a"; if (flags & TRANSPORT_PUSH_DRY_RUN) args[i++] = "--dry-run"; if (transport->verbose > 1) args[i++] = "-v"; args[i++] = "--ignore-existing"; args[i++] = "--exclude"; args[i++] = "info"; args[i++] = get_object_directory(); args[i++] = buf.buf; args[i++] = NULL; if (run_command(&rsync)) return error("Could not push objects to %s", rsync_url(transport->url)); /* copy the refs to the temporary directory; they could be packed. */ strbuf_addstr(&temp_dir, git_path("rsync-refs-XXXXXX")); if (!mkdtemp(temp_dir.buf)) die_errno ("Could not make temporary directory"); strbuf_addch(&temp_dir, '/'); if (flags & TRANSPORT_PUSH_ALL) { if (for_each_ref(write_one_ref, &temp_dir)) return -1; } else if (write_refs_to_temp_dir(&temp_dir, refspec_nr, refspec)) return -1; i = 2; if (flags & TRANSPORT_PUSH_DRY_RUN) args[i++] = "--dry-run"; if (!(flags & TRANSPORT_PUSH_FORCE)) args[i++] = "--ignore-existing"; args[i++] = temp_dir.buf; args[i++] = rsync_url(transport->url); args[i++] = NULL; if (run_command(&rsync)) result = error("Could not push to %s", rsync_url(transport->url)); if (remove_dir_recursively(&temp_dir, 0)) warning ("Could not remove temporary directory %s.", temp_dir.buf); strbuf_release(&buf); strbuf_release(&temp_dir); return result; }
void init() { if (not initialized) { mkdtemp(dictionary_tmpdir); atexit(cleanup_root_dictionaries); } }
/* We expect four arguments: - source directory name - object directory - common object directory - the program name with path */ int main (int argc, char *argv[]) { const char *srcdir; const char *objdir; const char *common_objdir; const char *progpath; struct stat64 st1; struct stat64 st2; struct stat64 st3; DIR *dir1; DIR *dir2; int result = 0; struct dirent64 *d; struct dirent64 direntbuf; char *objdir_copy1; char *objdir_copy2; char *buf; int fd; mtrace (); if (argc < 5) { puts ("not enough parameters"); exit (1); } /* Make parameters available with nicer names. */ srcdir = argv[1]; objdir = argv[2]; common_objdir = argv[3]; progpath = argv[4]; /* First test the current source dir. We cannot really compare the result of `getpwd' with the srcdir string but we have other means. */ if (stat64 (".", &st1) < 0) { printf ("cannot stat starting directory: %m\n"); exit (1); } if (chdir (srcdir) < 0) { printf ("cannot change to source directory: %m\n"); exit (1); } if (stat64 (".", &st2) < 0) { printf ("cannot stat source directory: %m\n"); exit (1); } /* The two last stat64 calls better were for the same directory. */ if (st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino) { printf ("stat of source directory failed: (%lld,%lld) vs (%lld,%lld)\n", (long long int) st1.st_dev, (long long int) st1.st_ino, (long long int) st2.st_dev, (long long int) st2.st_ino); exit (1); } /* Change to the object directory. */ if (chdir (objdir) < 0) { printf ("cannot change to object directory: %m\n"); exit (1); } if (stat64 (".", &st1) < 0) { printf ("cannot stat object directory: %m\n"); exit (1); } /* Is this the same we get as with the full path? */ if (stat64 (objdir, &st2) < 0) { printf ("cannot stat object directory with full path: %m\n"); exit (1); } if (st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino) { printf ("stat of object directory failed: (%lld,%lld) vs (%lld,%lld)\n", (long long int) st1.st_dev, (long long int) st1.st_ino, (long long int) st2.st_dev, (long long int) st2.st_ino); exit (1); } objdir_copy1 = getcwd (NULL, 0); if (objdir_copy1 == NULL) { printf ("cannot get current directory name for object directory: %m\n"); result = 1; } /* First test: this directory must include our program. */ if (stat64 (progpath, &st2) < 0) { printf ("cannot stat program: %m\n"); exit (1); } dir1 = opendir ("."); if (dir1 == NULL) { printf ("cannot open object directory: %m\n"); exit (1); } while ((d = readdir64 (dir1)) != NULL) { #ifdef _DIRENT_HAVE_D_TYPE if (d->d_type != DT_UNKNOWN && d->d_type != DT_REG) continue; #endif if (d->d_ino == st2.st_ino) { /* Might be it. Test the device. We could use the st_dev element from st1 but what the heck, do more testing. */ if (stat64 (d->d_name, &st3) < 0) { printf ("cannot stat entry from readdir: %m\n"); result = 1; d = NULL; break; } if (st3.st_dev == st2.st_dev) break; } } if (d == NULL) { puts ("haven't found program in object directory"); result = 1; } /* We leave dir1 open. */ /* Stat using file descriptor. */ if (fstat64 (dirfd (dir1), &st2) < 0) { printf ("cannot fstat object directory: %m\n"); result = 1; } if (st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino) { printf ("fstat of object directory failed: (%lld,%lld) vs (%lld,%lld)\n", (long long int) st1.st_dev, (long long int) st1.st_ino, (long long int) st2.st_dev, (long long int) st2.st_ino); exit (1); } if (chdir ("..") < 0) { printf ("cannot go to common object directory with \"..\": %m\n"); exit (1); } if (stat64 (".", &st1) < 0) { printf ("cannot stat common object directory: %m\n"); exit (1); } /* Is this the same we get as with the full path? */ if (stat64 (common_objdir, &st2) < 0) { printf ("cannot stat common object directory with full path: %m\n"); exit (1); } if (st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino) { printf ("stat of object directory failed: (%lld,%lld) vs (%lld,%lld)\n", (long long int) st1.st_dev, (long long int) st1.st_ino, (long long int) st2.st_dev, (long long int) st2.st_ino); exit (1); } /* Stat using file descriptor. */ if (fstat64 (dirfd (dir1), &st2) < 0) { printf ("cannot fstat object directory: %m\n"); result = 1; } dir2 = opendir (common_objdir); if (dir2 == NULL) { printf ("cannot open common object directory: %m\n"); exit (1); } while ((d = readdir64 (dir2)) != NULL) { #ifdef _DIRENT_HAVE_D_TYPE if (d->d_type != DT_UNKNOWN && d->d_type != DT_DIR) continue; #endif if (d->d_ino == st2.st_ino) { /* Might be it. Test the device. We could use the st_dev element from st1 but what the heck, do more testing. */ if (stat64 (d->d_name, &st3) < 0) { printf ("cannot stat entry from readdir: %m\n"); result = 1; d = NULL; break; } if (st3.st_dev == st2.st_dev) break; } } /* This better should be the object directory again. */ if (fchdir (dirfd (dir1)) < 0) { printf ("cannot fchdir to object directory: %m\n"); exit (1); } objdir_copy2 = getcwd (NULL, 0); if (objdir_copy2 == NULL) { printf ("cannot get current directory name for object directory: %m\n"); result = 1; } if (strcmp (objdir_copy1, objdir_copy2) != 0) { puts ("getcwd returned a different string the second time"); result = 1; } /* This better should be the common object directory again. */ if (fchdir (dirfd (dir2)) < 0) { printf ("cannot fchdir to common object directory: %m\n"); exit (1); } if (stat64 (".", &st2) < 0) { printf ("cannot stat common object directory: %m\n"); exit (1); } if (st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino) { printf ("stat of object directory failed: (%lld,%lld) vs (%lld,%lld)\n", (long long int) st1.st_dev, (long long int) st1.st_ino, (long long int) st2.st_dev, (long long int) st2.st_ino); exit (1); } buf = (char *) malloc (strlen (objdir_copy1) + 1 + sizeof "tst-dir.XXXXXX"); if (buf == NULL) { printf ("cannot allocate buffer: %m"); exit (1); } stpcpy (stpcpy (stpcpy (buf, objdir_copy1), "/"), "tst-dir.XXXXXX"); if (mkdtemp (buf) == NULL) { printf ("cannot create test directory in object directory: %m\n"); exit (1); } if (stat64 (buf, &st1) < 0) { printf ("cannot stat new directory \"%s\": %m\n", buf); exit (1); } if (chmod (buf, 0700) < 0) { printf ("cannot change mode of new directory: %m\n"); exit (1); } /* Try to find the new directory. */ rewinddir (dir1); while (readdir64_r (dir1, &direntbuf, &d) == 0 && d != NULL) { #ifdef _DIRENT_HAVE_D_TYPE if (d->d_type != DT_UNKNOWN && d->d_type != DT_DIR) continue; #endif if (d->d_ino == st1.st_ino) { /* Might be it. Test the device. We could use the st_dev element from st1 but what the heck, do more testing. */ size_t len = strlen (objdir) + 1 + _D_EXACT_NAMLEN (d) + 1; char tmpbuf[len]; stpcpy (stpcpy (stpcpy (tmpbuf, objdir), "/"), d->d_name); if (stat64 (tmpbuf, &st3) < 0) { printf ("cannot stat entry from readdir: %m\n"); result = 1; d = NULL; break; } if (st3.st_dev == st2.st_dev && strcmp (d->d_name, buf + strlen (buf) - 14) == 0) break; } } if (d == NULL) { printf ("haven't found new directory \"%s\"\n", buf); exit (1); } if (closedir (dir2) < 0) { printf ("closing dir2 failed: %m\n"); result = 1; } if (chdir (buf) < 0) { printf ("cannot change to new directory: %m\n"); exit (1); } dir2 = opendir (buf); if (dir2 == NULL) { printf ("cannot open new directory: %m\n"); exit (1); } if (fstat64 (dirfd (dir2), &st2) < 0) { printf ("cannot fstat new directory \"%s\": %m\n", buf); exit (1); } if (st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino) { printf ("stat of new directory failed: (%lld,%lld) vs (%lld,%lld)\n", (long long int) st1.st_dev, (long long int) st1.st_ino, (long long int) st2.st_dev, (long long int) st2.st_ino); exit (1); } if (mkdir ("another-dir", 0777) < 0) { printf ("cannot create \"another-dir\": %m\n"); exit (1); } fd = open ("and-a-file", O_RDWR | O_CREAT | O_EXCL, 0666); if (fd == -1) { printf ("cannot create \"and-a-file\": %m\n"); exit (1); } close (fd); /* Some tests about error reporting. */ errno = 0; if (chdir ("and-a-file") >= 0) { printf ("chdir to \"and-a-file\" succeeded\n"); exit (1); } if (errno != ENOTDIR) { printf ("chdir to \"and-a-file\" didn't set correct error\n"); result = 1; } errno = 0; if (chdir ("and-a-file/..") >= 0) { printf ("chdir to \"and-a-file/..\" succeeded\n"); exit (1); } if (errno != ENOTDIR) { printf ("chdir to \"and-a-file/..\" didn't set correct error\n"); result = 1; } errno = 0; if (chdir ("another-dir/../and-a-file") >= 0) { printf ("chdir to \"another-dir/../and-a-file\" succeeded\n"); exit (1); } if (errno != ENOTDIR) { printf ("chdir to \"another-dir/../and-a-file\" didn't set correct error\n"); result = 1; } /* We now should have a directory and a file in the new directory. */ rewinddir (dir2); while (readdir64_r (dir2, &direntbuf, &d) == 0 && d != NULL) { if (strcmp (d->d_name, ".") == 0 || strcmp (d->d_name, "..") == 0 || strcmp (d->d_name, "another-dir") == 0) { #ifdef _DIRENT_HAVE_D_TYPE if (d->d_type != DT_UNKNOWN && d->d_type != DT_DIR) { printf ("d_type for \"%s\" is wrong\n", d->d_name); result = 1; } #endif if (stat64 (d->d_name, &st3) < 0) { printf ("cannot stat \"%s\" is wrong\n", d->d_name); result = 1; } else if (! S_ISDIR (st3.st_mode)) { printf ("\"%s\" is no directory\n", d->d_name); result = 1; } } else if (strcmp (d->d_name, "and-a-file") == 0) { #ifdef _DIRENT_HAVE_D_TYPE if (d->d_type != DT_UNKNOWN && d->d_type != DT_REG) { printf ("d_type for \"%s\" is wrong\n", d->d_name); result = 1; } #endif if (stat64 (d->d_name, &st3) < 0) { printf ("cannot stat \"%s\" is wrong\n", d->d_name); result = 1; } else if (! S_ISREG (st3.st_mode)) { printf ("\"%s\" is no regular file\n", d->d_name); result = 1; } } else { printf ("unexpected directory entry \"%s\"\n", d->d_name); result = 1; } } if (stat64 ("does-not-exist", &st1) >= 0) { puts ("stat for unexisting file did not fail"); result = 1; } /* Free all resources. */ if (closedir (dir1) < 0) { printf ("closing dir1 failed: %m\n"); result = 1; } if (closedir (dir2) < 0) { printf ("second closing dir2 failed: %m\n"); result = 1; } if (rmdir ("another-dir") < 0) { printf ("cannot remove \"another-dir\": %m\n"); result = 1; } if (unlink ("and-a-file") < 0) { printf ("cannot remove \"and-a-file\": %m\n"); result = 1; } /* One more test before we leave: mkdir() is supposed to fail with EEXIST if the named file is a symlink. */ if (symlink ("a-symlink", "a-symlink") != 0) { printf ("cannot create symlink \"a-symlink\": %m\n"); result = 1; } else { if (mkdir ("a-symlink", 0666) == 0) { puts ("can make directory \"a-symlink\""); result = 1; } else if (errno != EEXIST) { puts ("mkdir(\"a-symlink\") does not fail with EEXIST\n"); result = 1; } if (unlink ("a-symlink") < 0) { printf ("cannot unlink \"a-symlink\": %m\n"); result = 1; } } if (chdir (srcdir) < 0) { printf ("cannot change back to source directory: %m\n"); exit (1); } if (rmdir (buf) < 0) { printf ("cannot remove \"%s\": %m\n", buf); result = 1; } free (objdir_copy1); free (objdir_copy2); if (result == 0) puts ("all OK"); return result; }