Exemplo n.º 1
0
rc_t CC KMain(int argc, char *argv[])
{
    static const char *help[] = { "--help", "-h", "-?", NULL };
    static const char *vers[] = { "--version", "-V", NULL };

    bool const has_help = has_arg(help, argc, argv);
    bool const has_vers = has_arg(vers, argc, argv);
    XMLLogger const *logger = NULL;
    int argfirst = 0;
    int arglast = 0;
    rc_t rc = 0;
    unsigned load = 0;

    if (has_help) {
        argc = 2;
        argv[1] = "--help";
        return main_help_vers(argc, argv);
    }
    if (has_vers) {
        argc = 2;
        argv[1] = "--version";
        return main_help_vers(argc, argv);
    }

    logger = make_logger(&argc, argv);

    memset(&G, 0, sizeof(G));
    G.mode = mode_Archive;
    G.globalMode = mode_Archive;
    G.maxSeqLen = TableWriterRefSeq_MAX_SEQ_LEN;
    G.schemaPath = strdup(SCHEMAFILE);
    G.omit_aligned_reads = true;
    G.omit_reference_reads = true;
    G.minMapQual = 0; /* accept all */
    G.tmpfs = strdup("/tmp");
    G.cache_size = ((size_t)16) << 30;
    G.maxErrCount = 1000;
    G.minMatchCount = 10;
    
    set_pid();

    for (arglast = 1; arglast < argc; ++arglast) {
        if (strcmp(argv[arglast], "--remap") == 0) {
            argv[arglast] = argv[0];
            G.globalMode = mode_Remap;
            rc = main_1(arglast - argfirst, argv + argfirst, true, load);
            if (rc)
                break;
            G.mode = mode_Remap;
            argfirst = arglast;
            ++load;
        }
    }
    rc = main_1(arglast - argfirst, argv + argfirst, false, load);
    XMLLogger_Release(logger);
    cleanupGlobal();
    return rc;
}
Exemplo n.º 2
0
std::string read_format_with_args(const std::string &fmt, size_t &index, bool &width_arg, bool &precision_arg,
                                  Format &format) {
    size_t start = index++, len = fmt.length();
    while (index < len && check_flags(fmt[index])) {
        index++;
    }
    if (fmt[index] == '*' || isdigit(fmt[index])) {
        width_arg = has_arg(fmt, index);
    }
    if (fmt[index] == '.') {
        precision_arg = has_arg(fmt, ++index);
    }
    check_specifier(fmt, index);
    format = get_format(fmt, index);
    return fmt.substr(start, index - start);
}
Exemplo n.º 3
0
void column_justify()
{
    vunits height;
    if (!the_column->is_active())
        error("can't justify column - column not active");
    else if (get_vunits(&height, 'v')) {
        justification_spec js(height);
        symbol nm = get_long_name(1);
        if (!nm.is_null()) {
            vunits v;
            if (get_vunits(&v, 'v')) {
                js.append(nm, v);
                int err = 0;
                while (has_arg()) {
                    nm = get_long_name(1);
                    if (nm.is_null()) {
                        err = 1;
                        break;
                    }
                    if (!get_vunits(&v, 'v')) {
                        err = 1;
                        break;
                    }
                    js.append(nm, v);
                }
                if (!err)
                    the_column->justify(js);
            }
        }
    }
    skip_line();
}
Exemplo n.º 4
0
void fcgi_upgrade_2_1_4(void) {
    rc_ty s;
    const sx_hashfs_volume_t *vol = NULL;
    const char *startname, *startrev = NULL;
    struct rplfiles ctx;

    if(!has_arg("maxrev"))
        quit_errmsg(400, "Parameter maxrev is required");

    startname = strchr(path, '/');
    if(!startname) {
        s = sx_hashfs_volume_by_name(hashfs, path, &vol);
    } else {
        unsigned int vnamelen = startname - path;
        char *vname = malloc(vnamelen + 1);
        if(!vname)
            quit_errmsg(503, "Out of memory");
        memcpy(vname, path, vnamelen);
        vname[vnamelen] = '\0';
        s = sx_hashfs_volume_by_name(hashfs, vname, &vol);
        free(vname);
        startname++;
        if(strlen(startname))
            startrev = get_arg("startrev");
        else
            startname = NULL;
    }
    if(s != OK)
        quit_errmsg(rc2http(s), msg_get_reason());

    if(!sx_hashfs_is_or_was_my_volume(hashfs, vol, 0))
        quit_errnum(404);

    ctx.bytes_sent = 0;
    ctx.b = sx_blob_new();
    if(!ctx.b)
        quit_errmsg(503, "Out of memory");

    s = sx_hashfs_file_find(hashfs, vol, startname, startrev, get_arg("maxrev"), upgrade_2_1_4_cb, &ctx);
    if(s == FAIL_ETOOMANY || s == ITER_NO_MORE) {
        sx_blob_reset(ctx.b);
        if(!sx_blob_add_string(ctx.b, "$FILE$") && !sx_blob_add_string(ctx.b, ctx.lastfile.name) &&
           !sx_blob_add_string(ctx.b, ctx.lastfile.revision))
            send_rplfiles_header(&ctx);
    }
    if(s == ITER_NO_MORE) {
        sx_blob_reset(ctx.b);
        if(!sx_blob_add_string(ctx.b, "$THEEND$"))
            send_rplfiles_header(&ctx);
        sx_blob_free(ctx.b);
        return;
    }

    sx_blob_free(ctx.b);
    if(s != FAIL_ETOOMANY && !ctx.bytes_sent)
        quit_errmsg(rc2http(s), msg_get_reason());
}
Exemplo n.º 5
0
void page_length()
{
  vunits n;
  if (has_arg() && get_vunits(&n, 'v', topdiv->get_page_length()))
    topdiv->set_page_length(n);
  else
    topdiv->set_page_length(11*units_per_inch);
  skip_line();
}
Exemplo n.º 6
0
void vertical_position_traps()
{
  int n;
  if (has_arg() && get_integer(&n))
    vertical_position_traps_flag = (n != 0);
  else
    vertical_position_traps_flag = 1;
  skip_line();
}
Exemplo n.º 7
0
void need_space()
{
  vunits n;
  if (!has_arg() || !get_vunits(&n, 'v'))
    n = curenv->get_vertical_spacing();
  while (!tok.newline() && !tok.eof())
    tok.next();
  curdiv->need(n);
  tok.next();
}
Exemplo n.º 8
0
void save_vertical_space()
{
  vunits x;
  if (!has_arg() || !get_vunits(&x, 'v'))
    x = curenv->get_vertical_spacing();
  if (curdiv->distance_to_next_trap() > x)
    curdiv->space(x, 1);
  else
    saved_space = x;
  skip_line();
}
Exemplo n.º 9
0
void change_trap()
{
  symbol s = get_name(1);
  if (!s.is_null()) {
    vunits x;
    if (has_arg() && get_vunits(&x, 'v'))
      topdiv->change_trap(s, x);
    else
      topdiv->remove_trap(s);
  }
  skip_line();
}
Exemplo n.º 10
0
void page_number()
{
  int n;

  // the ps4html register is set if we are using -Tps
  // to generate images for html
  reg *r = (reg *)number_reg_dictionary.lookup("ps4html");
  if (r == NULL)
    if (has_arg() && get_integer(&n, topdiv->get_page_number()))
      topdiv->set_next_page_number(n);
  skip_line();
}
Exemplo n.º 11
0
void begin_page()
{
  int got_arg = 0;
  int n = 0;		/* pacify compiler */
  if (has_arg() && get_integer(&n, topdiv->get_page_number()))
    got_arg = 1;
  while (!tok.newline() && !tok.eof())
    tok.next();
  if (curdiv == topdiv) {
    if (topdiv->before_first_page) {
      if (!break_flag) {
	if (got_arg)
	  topdiv->set_next_page_number(n);
	if (got_arg || !topdiv->no_space_mode)
	  topdiv->begin_page();
      }
      else if (topdiv->no_space_mode && !got_arg)
	topdiv->begin_page();
      else {
	/* Given this

         .wh 0 x
	 .de x
	 .tm \\n%
	 ..
	 .bp 3

	 troff prints

	 1
	 3

	 This code makes groff do the same. */

	push_page_ejector();
	topdiv->begin_page();
	if (got_arg)
	  topdiv->set_next_page_number(n);
	topdiv->set_ejecting();
      }
    }
    else {
      push_page_ejector();
      if (break_flag)
	curenv->do_break();
      if (got_arg)
	topdiv->set_next_page_number(n);
      if (!(topdiv->no_space_mode && !got_arg))
	topdiv->set_ejecting();
    }
  }
  tok.next();
}
Exemplo n.º 12
0
void page_offset()
{
  hunits n;
  // The troff manual says that the default scaling indicator is v,
  // but it is in fact m: v wouldn't make sense for a horizontally
  // oriented request.
  if (!has_arg() || !get_hunits(&n, 'm', topdiv->page_offset))
    n = topdiv->prev_page_offset;
  topdiv->prev_page_offset = topdiv->page_offset;
  topdiv->page_offset = n;
  topdiv->modified_tag.incl(MTSM_PO);
  skip_line();
}
Exemplo n.º 13
0
void diversion_trap()
{
  vunits n;
  if (has_arg() && get_vunits(&n, 'v')) {
    symbol s = get_name();
    if (!s.is_null())
      curdiv->set_diversion_trap(s, n);
    else
      curdiv->clear_diversion_trap();
  }
  else
    curdiv->clear_diversion_trap();
  skip_line();
}
Exemplo n.º 14
0
void space_request()
{
  postpone_traps();
  if (break_flag)
    curenv->do_break();
  vunits n;
  if (!has_arg() || !get_vunits(&n, 'v'))
    n = curenv->get_vertical_spacing();
  while (!tok.newline() && !tok.eof())
    tok.next();
  if (!unpostpone_traps() && !curdiv->no_space_mode)
    curdiv->space(n);
  else
    // The line might have had line spacing that was truncated.
    truncated_space += n;
  
  tok.next();
}
Exemplo n.º 15
0
void return_request()
{
  vunits dist = curdiv->marked_place - curdiv->get_vertical_position();
  if (has_arg()) {
    if (tok.ch() == '-') {
      tok.next();
      vunits x;
      if (get_vunits(&x, 'v'))
	dist = -x;
    }
    else {
      vunits x;
      if (get_vunits(&x, 'v'))
	dist = x >= V0 ? x - curdiv->get_vertical_position() : V0;
    }
  }
  if (dist < V0)
    curdiv->space(dist);
  skip_line();
}
Exemplo n.º 16
0
int			main(int argc, char **argv)
{
	int			done;
	t_env		*tenv;
	extern char	**environ;

	if (argc < 1)
	{
		ft_putendl("How did you get this far?");
		return (1);
	}
	done = 0;
	tenv = get_env(environ);
	if (has_arg(argv, 'c') == 1)
		ft_putstr(TRM_CLR);
	while (done == 0)
		done = loop(tenv);
	free_tenv(tenv);
	return (0);
}
Exemplo n.º 17
0
void define_number_reg()
{
  symbol nm = get_name(1);
  if (nm.is_null()) {
    skip_line();
    return;
  }
  reg *r = (reg *)number_reg_dictionary.lookup(nm);
  units v;
  units prev_value;
  if (!r || !r->get_value(&prev_value))
    prev_value = 0;
  if (get_number(&v, 'u', prev_value)) {
    if (r == 0) {
      r = new number_reg;
      number_reg_dictionary.define(nm, r);
    }
    r->set_value(v);
    if (tok.space() && has_arg() && get_number(&v, 'u'))
      r->set_increment(v);
  }
  skip_line();
}
Exemplo n.º 18
0
int _tmain(int argc, _TCHAR* argv[]) {
	int i;
	DWORD failures = 0;
	ULONGLONG size = 0;
	DWORD err;
	TCHAR *f;
	TCHAR sSize[64];
	
	parsed_args* args = parse_args(argc, argv);
	BOOL oneVolumeOnly = has_arg(args, TEXT("one-volume-only"), TEXT('\0'));

	PSID sid = NULL;
	PACL acl = NULL;
	BOOL takeownership;
	EXPLICIT_ACCESS ea[1];

	if (!args->file_count) {
		_ftprintf(stderr, TEXT("Usage: %s [options] file1 [file2 ...]\n\n"), args->program);
		_ftprintf(stderr, TEXT("  The files can be directories, files, or simple wildcards\n\n"));
		_ftprintf(stderr, TEXT("  Options:\n"));
		_ftprintf(stderr, TEXT("    --one-volume-only  do not delete files on other volumes when\n                       junctions/symbolic links/mount points are found"));
		return 1;
	}

	takeownership = EnableTakeOwnershipPriv();
	if (!takeownership) {
		_ftprintf(stderr, TEXT("! Failed to enable the Take Ownership privilege\n"));
		_ftprintf(stderr, TEXT("Make sure you are an Administrator or elevated\n"));
		_ftprintf(stderr, TEXT("We will still try to delete the files\n"));
	}
	sid = GetCurrentSID();
	if (!sid) {
		_ftprintf(stderr, TEXT("! Failed to get the current user's SID\n"));
		_ftprintf(stderr, TEXT("We will still try to delete the files\n"));
	} else {
		// Explicit Access: All Access
		ZeroMemory(&ea, 1*sizeof(EXPLICIT_ACCESS));
		ea[0].grfAccessPermissions = GENERIC_ALL;
		ea[0].grfAccessMode = SET_ACCESS;
		ea[0].grfInheritance = SUB_OBJECTS_ONLY_INHERIT;
		ea[0].Trustee.TrusteeForm = TRUSTEE_IS_SID;
		ea[0].Trustee.TrusteeType = TRUSTEE_IS_USER;
		ea[0].Trustee.ptstrName = (LPTSTR)sid;
		// Create the ACL
		err = SetEntriesInAcl(1, ea, NULL, &acl);
		if (err != ERROR_SUCCESS) {
			LogError(TEXT("SetEntriesInAcl"), err);
		}
	}

	files = vector_create(64);

	// Find all files to delete
	for (i = 0; i < args->file_count; i++) {
		DWORD attrib = GetFileAttributes(args->files[i]);
		if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY)) {
			vector_append(files, copyStr(args->files[i]));
			if (oneVolumeOnly && (attrib & FILE_ATTRIBUTE_REPARSE_POINT) && FileChangesVolume(args->files[i])) {
				continue;
			}
		}
		FindFiles(args->files[i], FALSE, oneVolumeOnly);
	}

	// Leave now if there is nothing to delete
	if (files->length == 0) {
		_tprintf(TEXT("No files found\n"));
		vector_destroy(files, TRUE);
		return 0;
	}

	// Correct security and delete files / directories
	for (i = files->length-1; i >= 0; i--) {
		WIN32_FILE_ATTRIBUTE_DATA attrib;
		BY_HANDLE_FILE_INFORMATION info;
		DWORD volumeSN = 0;
		f = (TCHAR*)files->x[i];
		if (!GetFileAttributesEx(f, GetFileExInfoStandard, &attrib))
			continue;
		CorrectSecurity(f, attrib.dwFileAttributes, takeownership, sid, acl, oneVolumeOnly);
		if (attrib.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
			if (!RemoveDirectory(f) && (err = DeleteWithSH(f)) != 0) {
				LogFileError(TEXT("Failed to delete folder"), f, err);
				failures++;
			}
		} else {
			if (!DeleteFile(f) && (err = DeleteWithSH(f)) != 0) {
				LogFileError(TEXT("Failed to delete file"), f, GetLastError());
				failures++;
			} else {
				size += attrib.nFileSizeLow;
				size += ((ULONGLONG)attrib.nFileSizeHigh) << 32;
			}
		}
	}

	// Show results
	if (size < 1000)			_sntprintf(sSize, 64, TEXT("%I64d bytes"), size);
	else if (size < 1000000)	_sntprintf(sSize, 64, TEXT("%.2f KB"), size / 1024.0);
	else if (size < 1000000000)	_sntprintf(sSize, 64, TEXT("%.2f MB"), size / 1024 / 1024.0);
	else						_sntprintf(sSize, 64, TEXT("%.2f GB"), size / 1024 / 1024 / 1024.0);
	_tprintf(TEXT("Deleted %d files (%s)\n"), files->length-failures, sSize);
	if (failures > 0)
		_tprintf(TEXT("Failed to delete %d files\n"), failures);

	// Cleanup
	vector_destroy(files, TRUE);
	LocalFree(acl);
	LocalFree(sid);
	free_parsed_args(args);

	return 0;
}
Exemplo n.º 19
0
void fcgi_create_file(void) {
    const struct jparse_actions acts = {
	JPACTS_INT64(
		     JPACT(cb_newfile_size, JPKEY("fileSize"))
		     ),
	JPACTS_STRING(
		      JPACT(cb_newfile_block, JPKEY("fileData"), JPANYITM),
		      JPACT(cb_newfile_addmeta, JPKEY("fileMeta"), JPANYKEY)
		      ),
	JPACTS_NULL(
		    JPACT(cb_newfile_delmeta, JPKEY("fileMeta"), JPANYKEY)
		    )
    };
    struct cb_newfile_ctx yctx;
    jparse_t *J;
    int len;
    rc_ty s;
    sx_hash_t revid;

    quit_unless_has(PRIV_CLUSTER); /* Just in case */

    if(!has_arg("rev") || !has_arg("revid") || strlen(get_arg("revid")) != SXI_SHA1_TEXT_LEN)
	quit_errmsg(500, "File revision missing");
    if(hex2bin(get_arg("revid"), SXI_SHA1_TEXT_LEN, revid.b, sizeof(revid.b)))
        quit_errmsg(400, "Failed to parse revision ID");

    s = sx_hashfs_createfile_begin(hashfs);
    switch (s) {
    case OK:
	break;
    case ENOENT:
	quit_errnum(404);
    case EINVAL:
	quit_errnum(400);
    default:
	WARN("sx_hashfs_createfile_begin failed: %d", s);
	quit_errmsg(rc2http(s), "Cannot initialize file upload");
    }

    yctx.filesize = -1;
    yctx.rc = EINVAL;

    J = sxi_jparse_create(&acts, &yctx, 0);
    if(!J) {
	sx_hashfs_createfile_end(hashfs);
	quit_errmsg(503, "Cannot create JSON parser");
    }

    while((len = get_body_chunk(hashbuf, sizeof(hashbuf))) > 0)
	if(sxi_jparse_digest(J, hashbuf, len))
	    break;

    if(len || sxi_jparse_done(J)) {
	send_error(rc2http(yctx.rc), sxi_jparse_geterr(J));
	sx_hashfs_createfile_end(hashfs);
	sxi_jparse_destroy(J);
	return;
    }
    sxi_jparse_destroy(J);

    auth_complete();
    quit_unless_authed();

    s = sx_hashfs_createfile_commit(hashfs, volume, path, get_arg("rev"), &revid, yctx.filesize, 0);
    if(s != OK)
	quit_errmsg(rc2http(s), msg_get_reason());

    CGI_PUTS("\r\n");
}
Exemplo n.º 20
0
void
Options::parse(int& argc, char**& argv)
{
  int current = 1;

  int nextKeep = 1;

  while (current != argc)
  {
    std::match_results<const char*> result;
    std::regex_match(argv[current], result, option_matcher);

    if (result.empty())
    {
      //not a flag

      //if true is returned here then it was consumed, otherwise it is
      //ignored
      if (consume_positional(argv[current]))
      {
      }
      else
      {
        argv[nextKeep] = argv[current];
        ++nextKeep;
      }
      //if we return from here then it was parsed successfully, so continue
    }
    else
    {
      //short or long option?
      if (result[4].length() != 0)
      {
        std::string s = result[4];

        for (int i = 0; i != s.size(); ++i)
        {
          std::string name(1, s[i]);
          auto iter = m_options.find(name);

          if (iter == m_options.end())
          {
            throw option_not_exists_exception(name);
          }

          auto value = iter->second;

          //if no argument then just add it
          if (!value->has_arg())
          {
            parse_option(value, name);
          }
          else
          {
            //it must be the last argument
            if (i + 1 == s.size())
            {
              checked_parse_arg(argc, argv, current+1, value, name);
              ++current;
            }
            else
            {
              //error
              throw option_requires_argument_exception(name);
            }
          }
        }
      }
      else if (result[1].length() != 0)
      {
        std::string name = result[1];
      
        auto iter = m_options.find(name);

        if (iter == m_options.end())
        {
          throw option_not_exists_exception(name);
        }

        auto opt = iter->second;

        //equals provided for long option?
        if (result[3].length() != 0)
        {
          //parse the option given

          //but if it doesn't take an argument, this is an error
          if (!opt->has_arg())
          {
            throw option_not_has_argument_exception(name, result[3]);
          }

          parse_option(opt, name, result[3]);
        }
        else
        {
          if (opt->has_arg())
          {
            //parse the next argument
            checked_parse_arg(argc, argv, current + 1, opt, name);

            ++current;
          }
          else
          {
            //parse with empty argument
            parse_option(opt, name);
          }
        }
      }

    }

    ++current;
  }

  argc = nextKeep;
}