void basic_feats(string targetname,bool is_bi,string mode,string gazfile,bool lowercase){
  cerr << "\nbasic_feats(tagged=" << is_bi << "," << mode << ",low=" << lowercase << ")";
  check_fname(targetname);
  ifstream in((targetname).c_str());
// #if USE_KF
//   ofstream out((targetname+"_basefeats_k").c_str());
// #else
//   ofstream out((targetname+"_basefeats").c_str());
// #endif
  gaz_server GZ;
  if (mode=="BIO"){
#if USE_MORPH_CACHE
    system("gunzip DATA/MORPH/MORPH_CACHE.gz");
    GZ.init(gazfile,maxspan_gaz,"DATA/MORPH/MORPH_CACHE");
    system("gzip DATA/MORPH/MORPH_CACHE");
#else
    GZ.init(gazfile,maxspan_gaz);
#endif
  }

  char strbuf[10000];
  while (in.peek() != -1){
    string id = "";
    in >> id;
    if (id != ""){
      vector<string> W, P, L,LOW, WLEMMA;
      while (in.peek() == 9){
	string w = "", pos = "", tag = "";
	if (mode == "POS"){
	  in >> w;
	  W.push_back(w);
	}
	else {
	  in >> w >> pos;
	  W.push_back(w);
	  P.push_back(pos);
	}
	if (is_bi){
	  in >> tag;
	  L.push_back(tag);
	}
      }
Ejemplo n.º 2
0
int handle_client(int csockfd, int timeout) {
    uint64_t fsize;
    ssize_t namelen;
    char buf[BUF_SZ];
    char path[DIRLEN + FNAME_LENGTH + 1];
    char *filename = path + DIRLEN;
    ssize_t nbytes;
    bool delete_file;

    /* reading filesize */
    nbytes = read_tout(csockfd, &fsize, sizeof(fsize), timeout, 0, false);
    if (nbytes != sizeof(fsize)) {
        log("Filesize reading error\n");
        return -1;
    }
    fsize = le64toh(fsize);

    if (fsize > ((uint64_t)1 << 62)) {
        log("Filesize is too big\n");
        send_code(csockfd, CODE_BAD_FILELEN, timeout);
        return -1;
    }

    if (send_code(csockfd, CODE_ACK, timeout))
        return -1;
    log("Filesize %llu accepted\n", fsize);

    /* reading filename */
    //memset(path, 0, sizeof(path));
    memcpy(path, DIRNAME, DIRLEN);

    nbytes = read_tout(csockfd, buf, sizeof(buf), timeout, MSG_PEEK, false);
    if (nbytes > 0) {
        namelen = fname_len(buf, nbytes);
        if (namelen <= 0 || namelen > FNAME_LENGTH) {
            log("Bad filename length\n");
            send_code(csockfd, CODE_BAD_FILELEN, timeout);
            return -1;
        }
        /* There is no lseek() for socket, so .. */
        read_tout(csockfd, filename, namelen + 1, 0, 0, true);
    } else {
        log("Filename reading error");
        send_code(csockfd, CODE_ERR_UNKNOWN, timeout);
        return -1;
    }

    if (!check_fname(filename)) {
        log("Bad filename (check_fname)!\n");
        send_code(csockfd, CODE_BAD_FILENAME, timeout);
        return -1;
    }

    if (access(path, F_OK) != -1) {
        send_code(csockfd, CODE_FILE_EXISTS, timeout);
        return -1;
    }
    int fd = open(path, O_CREAT | O_WRONLY, 0600);
    if (fd == -1) {
        perror("open()");
        if (errno == ENAMETOOLONG)
            send_code(csockfd, CODE_BAD_FILELEN, timeout);
        else
            send_code(csockfd, CODE_ERR_UNKNOWN, timeout);
        return -1;
    }

    if (send_code(csockfd, CODE_ACK, timeout))
        return -1;
    log("Filename `%s` accepted and file exchange started\n", filename);

    /* reading file */
    nbytes = 0;
    delete_file = false;

    do {
        fsize -= (uint64_t) nbytes;
        nbytes = read_tout(csockfd, buf, sizeof(buf), timeout, 0, false);
        if (nbytes > 0) {
            if (write(fd, buf, min(nbytes, fsize)) == -1) {
                perror("write()");
                send_code(csockfd, CODE_ERR_TRANSFER, timeout);
                delete_file = true;
                break;
            }
        }
    } while (nbytes > 0 && nbytes < fsize);

    if (nbytes < 0) {
        log("Error while transfer\n");
        send_code(csockfd, CODE_ERR_TRANSFER, timeout);
        delete_file = true;
    }

    close(fd);

    if (delete_file) {
        log("Deleting file\n");
        unlink(path);
        return -1;
    }

    if (send_code(csockfd, CODE_ACK, timeout))
        log("Warning: send_code was unsuccessful, but file recieved ok");
    log("File `%s` recieved ok!\n", path);

    return 0;
}
Ejemplo n.º 3
0
/* Program main */
int main(int argc, char *argv[]) {
    cuuid_t cuuid;
    int c, rtn;
    unsigned int n = 1;
    char *fname = NULL;
    FILE *fp = NULL;
    int fout = 0, nout = 0, fmat = PRINT_FORMAT_HEX_BACKET, vbose = 0, gen = 1;
    int option_index;
    char tag[3] = {0x0, 0x0, 0x0};

    static struct option long_options[] = {
        {"category",       required_argument, 0, 0},
        {"set-safe",       no_argument,       0, 0},
        {"set-master",     no_argument,       0, 0},
        {"set-public",     no_argument,       0, 0},
        {"set-sign",       no_argument,       0, 0},
        {"set-tag",        no_argument,       0, 0},
        {"set-strict",     no_argument,       0, 0},
        {"list-categories",no_argument,       0, 0},
        {"rev",            required_argument, 0, 0},
        {"tag",            required_argument, 0, 0},
        {"rand-seed",      required_argument, 0, 0},
        {"memory-seed",    required_argument, 0, 0},
        {"output-hex",     no_argument,       0, 'x'},
        {"output-number",  no_argument,       0, 'i'},
        {"verbose",        no_argument,       0, 'V'},
        {"version",        no_argument,       0, 'v'},
        {"help",           no_argument,       0, 'h'},
        {0,                0,                 0,  0 }
    };

    /* Register interrupt handler */
    signal(SIGINT, set_signint);

    while (1) {
        option_index = 0;

        c = getopt_long(argc, argv, "c:d:o:qxivVh", long_options, &option_index);
        if (c == -1)
            break;

        switch (c) {
            case 0:
                if (!strcmp("rand-seed", long_options[option_index].name)) {
                    quid_set_rnd_seed(atoi(optarg));
                } else if (!strcmp("memory-seed", long_options[option_index].name)) {
                    quid_set_mem_seed(atoi(optarg));
                } else if (!strcmp("rev", long_options[option_index].name)) {
                    switch (atoi(optarg)) {
                        case 4:
                            cuuid.version = QUID_REV4;
                            break;
                        case 7:
                        default:
                            cuuid.version = QUID_REV7;
                            break;
                    }
                } else if (!strcmp("tag", long_options[option_index].name)) {
                    if (strlen(optarg) != 3) {
                        printf("tag must be 3 characters\n");
                        printf("see --help for more information\n");
                        return 1;
                    }
                    tag[0] = optarg[0];
                    tag[1] = optarg[1];
                    tag[2] = optarg[2];
                } else if (!strcmp("list-categories", long_options[option_index].name)) {
                    printf("%d) %s\n", CLS_CMON, category_name(CLS_CMON));
                    printf("%d) %s\n", CLS_INFO, category_name(CLS_INFO));
                    printf("%d) %s\n", CLS_WARN, category_name(CLS_WARN));
                    printf("%d) %s\n", CLS_ERROR, category_name(CLS_ERROR));
                    gen = 0;
                } else if (!strcmp("set-safe", long_options[option_index].name)) {
                    flg |= IDF_IDSAFE;
                } else if (!strcmp("set-public", long_options[option_index].name)) {
                    flg |= IDF_PUBLIC;
                } else if (!strcmp("set-master", long_options[option_index].name)) {
                    flg |= IDF_MASTER;
                } else if (!strcmp("set-tag", long_options[option_index].name)) {
                    flg |= IDF_TAGGED;
                } else if (!strcmp("set-strict", long_options[option_index].name)) {
                    flg |= IDF_STRICT;
                } else if (!strcmp("set-sign", long_options[option_index].name)) {
                    flg |= IDF_SIGNED;
                } else if (!strcmp("category", long_options[option_index].name)) {
                    cat = (char)atoi(optarg);
                    switch (cat) {
                        case CLS_CMON:
                        case CLS_INFO:
                        case CLS_WARN:
                        case CLS_ERROR:
                            break;
                        default:
                            printf("unknown category %d\n", cat);
                            printf("see --help for more information\n");
                            return 1;
                    }
                }
                break;
            case 'c':
                n = atoi(optarg);
                break;
            case 'd':
                delay = atoi(optarg);
                break;
            case 'o':
                fname = optarg;
                fout = 1;
                break;
            case 'x':
                fmat = PRINT_FORMAT_HEX;
                break;
            case 'i':
                fmat = PRINT_FORMAT_DEC;
                break;
            case 'q':
                nout = 1;
                break;
            case 'V':
                vbose = 1;
                break;
            case 'v':
                print_version();
                return 0;
            case 'h':
            case '?':
            default:
                usage();
                return 0;
        }
    }

    /* Identifier as positional argument */
    if (optind < argc) {
        cuuid_t uuid;
        while (optind < argc) {
            printf("%s\t", argv[optind]);
            if (quid_parse(argv[optind], &uuid)) {
                printf("VALID\n");
                if (vbose)
                    input_verbose(uuid);
            } else
                printf("INVALID\n");
            optind++;
        }

        return 0;
    }

    /* Output new identifiers */
    if (gen) {
        gettimeofday(&t1, NULL);

        /* File output */
        if (fout) {
            rtn = check_fname(fname);
            if (!rtn) {
                fp = fopen(fname, "a");
            } else if (rtn == 1) {
                printf("%s is a directory\n", fname);
                return 1;
            } else if (rtn == 2){
                printf("%s already exists\n", fname);
                return 1;
            }
        }

        for (i=0; i<n; ++i) {
            assert(cat != 0);
            quid_create(&cuuid, flg, cat, tag);

            if (intflag) {
                break;
            }

            if (!fout){
                if (!nout) {
                    quid_print(cuuid, fmat);
                }
            } else {
                quid_print_file(fp, cuuid, fmat);
            }

            if (delay) {
                qusleep(delay * 1000);
            }

            ticks = clock();
        }

        if (fp) {
            fclose(fp);
        }

        gettimeofday(&t2, NULL);
    }

    /* Show counters */
    if (vbose && gen) {
        generate_verbose();
    }

    return 0;
}