示例#1
0
static int
do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc )
{
  int rc = 0;
  int n, i;
  IOBUF a = iobuf_temp();
  
  write_version( a, ctb );
  if ( enc->throw_keyid ) 
    {
      write_32(a, 0 );  /* Don't tell Eve who can decrypt the message.  */
      write_32(a, 0 );
    }
  else
    {
      write_32(a, enc->keyid[0] );
      write_32(a, enc->keyid[1] );
    }
  iobuf_put(a,enc->pubkey_algo );
  n = pubkey_get_nenc( enc->pubkey_algo );
  if ( !n )
    write_fake_data( a, enc->data[0] );
  for (i=0; i < n && !rc ; i++ )
    rc = mpi_write(a, enc->data[i] );

  if (!rc)
    {
      write_header(out, ctb, iobuf_get_temp_length(a) );
      rc = iobuf_write_temp( out, a );
    }
  iobuf_close(a);
  return rc;
}
示例#2
0
文件: fix-db.c 项目: NUOG/ejudge
int
main(int argc, char *argv[])
{
  program_name = os_GetBasename(argv[0]);
  logger_set_level(-1, LOG_WARNING);

  if (argc < 1) die("not enough parameters");

  if (argc == 2) {
    if (!strcmp(argv[1], "--help")) {
      write_help();
    } else if (!strcmp(argv[1], "--version")) {
      write_version();
    }
  }

#if defined EJUDGE_XML_PATH
  if (!ejudge_xml_path) ejudge_xml_path = EJUDGE_XML_PATH;
#endif /* EJUDGE_XML_PATH */
  if (!ejudge_xml_path) die("ejudge.xml path is not specified");
  if (!(ejudge_config = ejudge_cfg_parse(ejudge_xml_path, 1))) return 1;
  if (!ejudge_config->contests_dir) die("<contests_dir> tag is not set!");
  if (contests_set_directory(ejudge_config->contests_dir) < 0)
    die("contests directory is invalid");

  load_mysql_plugin();

  /* consult the main compilation configuration */
  compile_cfg_path[0] = 0;
  if (ejudge_config->compile_home_dir) {
    snprintf(compile_cfg_path, sizeof(compile_cfg_path), "%s/conf/compile.cfg",
             ejudge_config->compile_home_dir);
  }
  if (!compile_cfg_path[0] && ejudge_config->contests_home_dir) {
    snprintf(compile_cfg_path, sizeof(compile_cfg_path), "%s/compile/conf/compile.cfg",
             ejudge_config->contests_home_dir);
  }
#if defined EJUDGE_CONTESTS_HOME_DIR
  if (!compile_cfg_path[0]) {
    snprintf(compile_cfg_path, sizeof(compile_cfg_path), "%s/compile/conf/compile.cfg",
             EJUDGE_CONTESTS_HOME_DIR);
  }
#endif

  cs_config = prepare_parse_config_file(compile_cfg_path, 0);
  if (!cs_config) {
    die("failed to parse compilation configuration file %s", compile_cfg_path);
  }
  handle_cs_config();

  process_all_contests();

  return 0;
}
示例#3
0
static void *logwriter_thread(void *arg)
{
	/* set name */
	prctl(PR_SET_NAME, "sdlog2_writer", 0);

	int log_fd = open_log_file();

	if (log_fd < 0) {
		return NULL;
	}

	struct logbuffer_s *logbuf = (struct logbuffer_s *)arg;

	/* write log messages formats, version and parameters */
	log_bytes_written += write_formats(log_fd);

	log_bytes_written += write_version(log_fd);

	log_bytes_written += write_parameters(log_fd);

	fsync(log_fd);

	int poll_count = 0;

	void *read_ptr;

	int n = 0;

	bool should_wait = false;

	bool is_part = false;

	while (true) {
		/* make sure threads are synchronized */
		pthread_mutex_lock(&logbuffer_mutex);

		/* update read pointer if needed */
		if (n > 0) {
			logbuffer_mark_read(&lb, n);
		}

		/* only wait if no data is available to process */
		if (should_wait && !logwriter_should_exit) {
			/* blocking wait for new data at this line */
			pthread_cond_wait(&logbuffer_cond, &logbuffer_mutex);
		}

		/* only get pointer to thread-safe data, do heavy I/O a few lines down */
		int available = logbuffer_get_ptr(logbuf, &read_ptr, &is_part);

		/* continue */
		pthread_mutex_unlock(&logbuffer_mutex);

		if (available > 0) {
			/* do heavy IO here */
			if (available > MAX_WRITE_CHUNK) {
				n = MAX_WRITE_CHUNK;

			} else {
				n = available;
			}

			n = write(log_fd, read_ptr, n);

			should_wait = (n == available) && !is_part;

			if (n < 0) {
				main_thread_should_exit = true;
				err(1, "error writing log file");
			}

			if (n > 0) {
				log_bytes_written += n;
			}

		} else {
			n = 0;

			/* exit only with empty buffer */
			if (main_thread_should_exit || logwriter_should_exit) {
				break;
			}

			should_wait = true;
		}

		if (++poll_count == 10) {
			fsync(log_fd);
			poll_count = 0;
		}
	}

	fsync(log_fd);
	close(log_fd);

	return NULL;
}
示例#4
0
int
main(int argc, char **argv)
{
  struct rsa_session ctx;
  struct rsa_session_info info;
  
  struct rsa_public_key key;
  mpz_t x;
  
  int c;
  const char *random_name = NULL;

  enum { OPT_HELP = 300 };
  
  static const struct option options[] =
    {
      /* Name, args, flag, val */
      { "help", no_argument, NULL, OPT_HELP },
      { "random", required_argument, NULL, 'r' },
      { NULL, 0, NULL, 0}
    };
  
  while ( (c = getopt_long(argc, argv, "o:r:", options, NULL)) != -1)
    switch (c)
      {
      case 'r':
	random_name = optarg;
	break;
	
      case '?':
	return EXIT_FAILURE;

      case OPT_HELP:
	usage(stdout);
	return EXIT_SUCCESS;
      default:
	abort();
      }

  argv += optind;
  argc -= optind;

  if (argc != 1)
    {
      usage (stderr);
      return EXIT_FAILURE;
    }

  rsa_public_key_init(&key);
  
  if (!read_rsa_key(argv[0], &key, NULL))
    {
      werror("Invalid key\n");
      return EXIT_FAILURE;
    }

  /* NOTE: No sources */
  yarrow256_init(&ctx.yarrow, 0, NULL);
  
  /* Read some data to seed the generator */
  if (!simple_random(&ctx.yarrow, random_name))
    {
      werror("Initialization of randomness generator failed.\n");
      return EXIT_FAILURE;
    }

  WRITE_UINT32(SESSION_VERSION(&info), RSA_VERSION);
  
  yarrow256_random(&ctx.yarrow, sizeof(info.key) - 4, info.key + 4);

  rsa_session_set_encrypt_key(&ctx, &info);
  
#ifdef WIN32
  _setmode(0, O_BINARY);
  _setmode(1, O_BINARY);
#endif

  write_version(stdout);
  
  mpz_init(x);

  if (!rsa_encrypt(&key,
		   &ctx.yarrow, (nettle_random_func *) yarrow256_random,
		   sizeof(info.key), info.key, 
		   x))
    {
      werror("RSA encryption failed.\n");
      return EXIT_FAILURE;
    }

  write_bignum(stdout, x);

  mpz_clear (x);

  if (!process_file(&ctx,
		    stdin, stdout))
    return EXIT_FAILURE;

  rsa_public_key_clear(&key);

  return EXIT_SUCCESS;
}
示例#5
0
int
main(int argc, char *argv[])
{
  int i = 1, r = 0;
  const char *command = 0;
  const char *ejudge_xml_path = 0;
  struct ejudge_cfg *config = 0;
  int cmd = 0;
  int super_serve_fd = -1;
  int signum = 0;
  const unsigned char *signame = "";
  int pid;

  program_name = os_GetBasename(argv[0]);
  if (argc < 2) startup_error("not enough parameters");

  if (!strcmp(argv[i], "--help")) {
    write_help();
  } else if (!strcmp(argv[i], "--version")) {
    write_version();
  }

  command = argv[i];
  i++;

  if (i < argc) {
    ejudge_xml_path = argv[i];
    i++;
  }

  if (i < argc) startup_error("too many parameters");

#if defined EJUDGE_XML_PATH
  if (!ejudge_xml_path) ejudge_xml_path = EJUDGE_XML_PATH;
#endif /* EJUDGE_XML_PATH */

  if (!ejudge_xml_path) startup_error("ejudge.xml path is not specified");

  if (!(config = ejudge_cfg_parse(ejudge_xml_path))) return 1;

  if (!strcmp(command, "stop")) {
    cmd = SSERV_CMD_STOP;
    signum = START_STOP;
    signame = "TERM";
  } else if (!strcmp(command, "restart")) {
    cmd = SSERV_CMD_RESTART;
    signum = START_RESTART;
    signame = "HUP";
  } else {
    startup_error("invalid command");
  }

  (void) signame;
  (void) signum;

  if (!(pid = start_find_process("ej-super-server", 0))) {
    op_error("ej-super-server is not running");
  } else if (pid > 0) {
    /*
    fprintf(stderr, "%s: ej-super-server is running as pid %d\n",
            program_name, pid);
    fprintf(stderr, "%s: sending it the %s signal\n", program_name, signame);
    if (start_kill(pid, signum) < 0) op_error("failed: %s", os_ErrorMsg());
    return 0;
    */
  }

  if ((super_serve_fd = super_clnt_open(config->super_serve_socket)) < 0)
    op_error("ej-super-server is not running");
  r = super_clnt_control(super_serve_fd, cmd);
  if (r < 0) op_error("%s", super_proto_strerror(-r));

  return 0;
}
示例#6
0
int main(int argc, char *argv[])
{
  int i;
  BOOL verbose = TRUE;
  BOOL very_verbose = TRUE;
  F64 start_time = 0.0;
  F64 full_start_time = 0.0;
  const CHAR* xml_output_file = 0;
  BOOL one_report_per_file = FALSE;
  U32 num_pass = 0;
  U32 num_fail = 0;
  U32 num_warning = 0;

  fprintf(stderr, "This is version '%s' of the LAS validator. Please contact\n", "GRiD-1");
  fprintf(stderr, "me at '*****@*****.**' if you disagree with\n");
  fprintf(stderr, "validation reports, want additional checks, or find bugs as\n");
  fprintf(stderr, "the software is still under development. Your feedback will\n");
  fprintf(stderr, "help to finish it sooner.\n");

  LASreadOpener lasreadopener;

  if (argc == 1)
  {
    fprintf(stderr,"lasvalidate.exe is best run with arguments in the command line\n");
    char file_name[256];
    fprintf(stderr,"enter input LAS file name: "); fgets(file_name, 256, stdin);
    file_name[strlen(file_name)-1] = '\0';
    lasreadopener.set_file_name(file_name);
    fprintf(stderr,"enter output XML file name: "); fgets(file_name, 256, stdin);
    file_name[strlen(file_name)-1] = '\0';
    xml_output_file = strdup(file_name);
  }

  for (i = 1; i < argc; i++)
  {
    if (strcmp(argv[i],"-version") == 0)
    {
      fprintf(stderr, "\nlasvalidate %d with LASread (v %d.%d %d) and LAScheck (v %d.%d %d) by rapidlasso GmbH\n", VALIDATE_VERSION, LASREAD_VERSION_MAJOR, LASREAD_VERSION_MINOR, LASREAD_BUILD_DATE, LASCHECK_VERSION_MAJOR, LASCHECK_VERSION_MINOR, LASCHECK_BUILD_DATE);
      byebye(LAS_VALIDATE_SUCCESS);
    }
    else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0)
    {
      lasreadopener.usage();
      usage(LAS_VALIDATE_SUCCESS);
    }
    else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0)
    {
      verbose = TRUE;
    }
    else if (strcmp(argv[i],"-vv") == 0 || strcmp(argv[i],"-very_verbose") == 0)
    {
      verbose = TRUE;
      very_verbose = TRUE;
    }
    else if (strcmp(argv[i],"-i") == 0)
    {
      if ((i+1) >= argc)
      {
        fprintf(stderr,"ERROR: '%s' needs at least 1 argument: file_name or wild_card\n", argv[i]);
        usage(LAS_VALIDATE_WRONG_COMMAND_LINE_SYNTAX);
      }
      i+=1;
      do
      {
        lasreadopener.add_file_name(argv[i]);
        i+=1;
      } while (i < argc && *argv[i] != '-');
      i-=1;
    }
    else if (strcmp(argv[i],"-irec") == 0)
    {
      if ((i+1) >= argc)
      {
        fprintf(stderr,"ERROR: '%s' needs at least 1 argument: directory_name\n", argv[i]);
        usage(LAS_VALIDATE_WRONG_COMMAND_LINE_SYNTAX);
      }
      i+=1;
      do
      {
        lasreadopener.add_directory(argv[i], TRUE);
        i+=1;
      } while (i < argc && *argv[i] != '-');
      i-=1;
    }
    else if (strcmp(argv[i],"-stdin") == 0)
    {
      lasreadopener.set_piped(TRUE);
    }
    else if (strcmp(argv[i],"-lof") == 0)
    {
      if ((i+1) >= argc)
      {
        fprintf(stderr,"ERROR: '%s' needs 1 argument: list_of_files\n", argv[i]);
        usage(LAS_VALIDATE_WRONG_COMMAND_LINE_SYNTAX);
      }
      FILE* file = fopen(argv[i+1], "r");
      if (file == 0)
      {
        fprintf(stderr, "ERROR: cannot open '%s'\n", argv[i+1]);
        return FALSE;
      }
      char line[1024];
      while (fgets(line, 1024, file))
      {
        // find end of line
        int len = strlen(line) - 1;
        // remove extra white spaces and line return at the end 
        while (len > 0 && ((line[len] == '\n') || (line[len] == ' ') || (line[len] == '\t') || (line[len] == '\012')))
        {
          line[len] = '\0';
          len--;
        }
        lasreadopener.add_file_name(line);
      }
      fclose(file);
      i+=1;
    }
    else if (strcmp(argv[i],"-o") == 0)
    {
      i++;
      xml_output_file = argv[i];
    }
    else if (strcmp(argv[i],"-oxml") == 0)
    {
      one_report_per_file = TRUE;
    }
    else
    {
      fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]);
      usage(LAS_VALIDATE_WRONG_COMMAND_LINE_SYNTAX);
    }
  }

  // in verbose mode we measure the total time

  if (verbose) full_start_time = taketime();

  // check input

  if (!lasreadopener.is_active())
  {
    fprintf(stderr,"ERROR: no input specified\n");
    byebye(LAS_VALIDATE_NO_INPUT_SPECIFIED, argc == 1);
  }

  // output logging

  XMLwriter xmlwriter;

  if (lasreadopener.is_active())
  {
    if (xml_output_file)
    {
      one_report_per_file = FALSE;
    }
    else if (!one_report_per_file)
    {
      xml_output_file = "validate.xml";
    }
  }

  // maybe we are doing one summary report

  if (xml_output_file)
  {
    if (!xmlwriter.open(xml_output_file, "LASvalidator"))
    {
      byebye(LAS_VALIDATE_WRITE_PERMISSION_ERROR, argc == 1);
    }
  }

  // accumulated pass

  U32 total_pass = VALIDATE_PASS;

  // possibly loop over multiple input files

  while (lasreadopener.is_active())
  {
    // in very verbose mode we measure the time for each file

    if (very_verbose) start_time = taketime();

    // open lasreader

    LASreader* lasreader = lasreadopener.open();
    if (lasreader == 0)
    {
      fprintf(stderr, "ERROR: could not open lasreader\n");
      byebye(LAS_VALIDATE_INPUT_FILE_NOT_FOUND, argc == 1);
    }

    // get a pointer to the header
    LASheader* lasheader = &lasreader->header;

    // maybe we are doing one report per file

    if (one_report_per_file)
    {
      int len = strlen(lasreadopener.get_path());
      CHAR* current_xml_output_file = (CHAR*)malloc(len + 5);
      strcpy(current_xml_output_file, lasreadopener.get_path());
      current_xml_output_file[len-4] = '_';
      current_xml_output_file[len-3] = 'L';
      current_xml_output_file[len-2] = 'V';
      current_xml_output_file[len-1] = 'S';
      current_xml_output_file[len  ] = '.';
      current_xml_output_file[len+1] = 'x';
      current_xml_output_file[len+2] = 'm';
      current_xml_output_file[len+3] = 'l';
      current_xml_output_file[len+4] = '\0';
      if (!xmlwriter.open(current_xml_output_file, "LASvalidator"))
      {
        byebye(LAS_VALIDATE_WRITE_PERMISSION_ERROR, argc == 1);
      }
      free(current_xml_output_file);
    }

    // start a new report
    
    xmlwriter.begin("report");

    // report description of file

    xmlwriter.beginsub("file");
    xmlwriter.write("name", lasreadopener.get_file_name());
    xmlwriter.write("path", lasreadopener.get_path());
    CHAR temp[32];
    sprintf(temp, "%d.%d", lasheader->version_major, lasheader->version_minor);
    xmlwriter.write("version", temp);
    strncpy(temp, lasheader->system_identifier, 32);
    temp[31] = '\0';
    xmlwriter.write("system_identifier", temp);
    strncpy(temp, lasheader->generating_software, 32);
    temp[31] = '\0';
    xmlwriter.write("generating_software", temp);
    xmlwriter.write("point_data_format", lasheader->point_data_format);

    CHAR crsdescription[512];
    strcpy(crsdescription, "not valid or not specified");

    if (lasheader->fails == 0)
    {
      // header was loaded. now parse and check.

      LAScheck lascheck(lasheader);

      while (lasreader->read_point())
      {
        lascheck.parse(&lasreader->point);
      }

      // check header and points and get CRS description

      lascheck.check(lasheader, crsdescription);
    }

    xmlwriter.write("CRS", crsdescription);
    xmlwriter.endsub("file");    

    // report the verdict

    U32 pass = (lasheader->fails ? VALIDATE_FAIL : VALIDATE_PASS);
    if (lasheader->warnings) pass |= VALIDATE_WARNING;

    xmlwriter.beginsub("summary");
    xmlwriter.write((pass == VALIDATE_PASS ? "pass" : ((pass & VALIDATE_FAIL) ? "fail" : "warning")));
    xmlwriter.endsub("summary");

    // report details (if necessary)

    if (pass != VALIDATE_PASS)
    {
      xmlwriter.beginsub("details");
      for (i = 0; i < lasheader->fail_num; i+=2)
      {
        xmlwriter.write(lasheader->fails[i], "fail", lasheader->fails[i+1]);
      }
      for (i = 0; i < lasheader->warning_num; i+=2)
      {
        xmlwriter.write(lasheader->warnings[i], "warning", lasheader->warnings[i+1]);
      }
      xmlwriter.endsub("details");
      total_pass |= pass;
      if (pass & VALIDATE_FAIL)
      {
        num_fail++;
      }
      else
      {
        num_warning++;
      }
    }
    else
    {
      num_pass++;
    }

    // end the report

    xmlwriter.end("report");

    // maybe we are doing one report per file

    if (one_report_per_file)
    {
      // report the total verdict

      xmlwriter.begin("total");
      xmlwriter.write((total_pass == VALIDATE_PASS ? "pass" : ((total_pass & VALIDATE_FAIL) ? "fail" : "warning")));
      xmlwriter.beginsub("details");
      xmlwriter.write("pass", num_pass);
      xmlwriter.write("warning", num_warning);
      xmlwriter.write("fail", num_fail);
      xmlwriter.endsub("details");
      xmlwriter.end("total");

      num_pass = 0;
      num_warning = 0;
      num_fail = 0;

      // write which validator was used

      write_version(xmlwriter);

      // write which command line was used

      write_command_line(xmlwriter, argc, argv);

      // close the LASvalidator XML output file

      xmlwriter.close("LASvalidator");
    }

    lasreader->close();
    delete lasreader;

    // in very verbose mode we report the time for each file

    if (very_verbose)
    {
      fprintf(stderr,"needed %.2f sec for '%s'\n", taketime()-start_time, lasreadopener.get_file_name());
      start_time = taketime();
    }
  }

  // maybe we are doing one summary report

  if (!one_report_per_file)
  {
    // report the total verdict

    xmlwriter.begin("total");
    xmlwriter.write((total_pass == 0 ? "pass" : ((total_pass & 1) ? "fail" : "warning")));
    xmlwriter.beginsub("details");
    xmlwriter.write("pass", num_pass);
    xmlwriter.write("warning", num_warning);
    xmlwriter.write("fail", num_fail);
    xmlwriter.endsub("details");
    xmlwriter.end("total");

    // write which validator was used

    write_version(xmlwriter);

    // write which command line was used

    write_command_line(xmlwriter, argc, argv);

    // close the LASvalidator XML output file

    xmlwriter.close("LASvalidator");
  }

  // in verbose mode we report the total time

  if (verbose && (lasreadopener.get_file_name_number() > 1))
  {
    fprintf(stderr,"done. total time %.2f sec.\n", taketime()-full_start_time);
  }

  byebye(argc==1);

  return 0;
}
示例#7
0
int main(int argc, char **argv)
{
    int         i, n_valid, do_write, do_scrub;
    char       *c, *dname, *name;
    DIR        *dir;
    FILE       *fp;
    pdf_t      *pdf;
    pdf_flag_t  flags;

    if (argc < 2)
      usage();

    /* Args */
    do_write = do_scrub = flags = 0;
    name = NULL;
    for (i=1; i<argc; i++)
    {
        if (strncmp(argv[i], "-w", 2) == 0)
          do_write = 1;
        else if (strncmp(argv[i], "-i", 2) == 0)
          flags |= PDF_FLAG_DISP_CREATOR;
        else if (strncmp(argv[i], "-q", 2) == 0)
          flags |= PDF_FLAG_QUIET;
        else if (strncmp(argv[i], "-s", 2) == 0)
          do_scrub = 1;
        else if (argv[i][0] != '-')
          name = argv[i];
        else if (argv[i][0] == '-')
          usage();
    }

    if (!name)
      usage();

    if (!(fp = fopen(name, "r")))
    {
        ERR("Could not open file '%s'\n", argv[1]);
        return -1;
    }
    else if (!pdf_is_pdf(fp))
    {
        ERR("'%s' specified is not a valid PDF\n", name);
        fclose(fp);
        return -1;
    }

    /* Load PDF */
    if (!(pdf = init_pdf(fp, name)))
    {
        fclose(fp);
        return -1;
    }

    /* Count valid xrefs */
    for (i=0, n_valid=0; i<pdf->n_xrefs; i++)
      if (pdf->xrefs[i].version)
        ++n_valid;

    /* Bail if we only have 1 valid */
    if (n_valid < 2)
    {
        if (!(flags & (PDF_FLAG_QUIET | PDF_FLAG_DISP_CREATOR)))
          printf("%s: There is only one version of this PDF\n", pdf->name);

        if (do_write)
        {
            fclose(fp);
            pdf_delete(pdf);
            return 0;
        }
    }

    dname = NULL;
    if (do_write)
    {
        /* Create directory to place the various versions in */
        if ((c = strrchr(name, '/')))
          name = c + 1;

        if ((c = strrchr(name, '.')))
          *c = '\0';

        dname = malloc(strlen(name) + 16);
        sprintf(dname, "%s-versions", name);
        if (!(dir = opendir(dname)))
          mkdir(dname, S_IRWXU);
        else
        {
            ERR("This directory already exists, PDF version extraction will "
                "not occur\n");
            fclose(fp);
            closedir(dir);
            free(dname);
            pdf_delete(pdf);
            return -1;
        }
    
        /* Write the pdf as a pervious version */
        for (i=0; i<pdf->n_xrefs; i++)
          if (pdf->xrefs[i].version)
            write_version(fp, name, dname, &pdf->xrefs[i]);
    }

    /* Generate a per-object summary */
    pdf_summarize(fp, pdf, dname, flags);

    /* Have we been summoned to scrub history from this PDF */
    if (do_scrub)
      scrub_document(fp, pdf);

    /* Display extra information */
    if (flags & PDF_FLAG_DISP_CREATOR)
      display_creator(fp, pdf);

    fclose(fp);
    free(dname);
    pdf_delete(pdf);

    return 0;
}
示例#8
0
static void run_linker_config_smoke_test(bool is_asan) {
  const std::vector<std::string> kExpectedDefaultSearchPath =
      resolve_paths(is_asan ? std::vector<std::string>({ "/data", "/vendor/lib" ARCH_SUFFIX }) :
                              std::vector<std::string>({ "/vendor/lib" ARCH_SUFFIX }));

  const std::vector<std::string> kExpectedDefaultPermittedPath =
      resolve_paths(is_asan ? std::vector<std::string>({ "/data", "/vendor" }) :
                              std::vector<std::string>({ "/vendor/lib" ARCH_SUFFIX }));

  const std::vector<std::string> kExpectedSystemSearchPath =
      resolve_paths(is_asan ? std::vector<std::string>({ "/data", "/system/lib" ARCH_SUFFIX }) :
                              std::vector<std::string>({ "/system/lib" ARCH_SUFFIX }));

  const std::vector<std::string> kExpectedSystemPermittedPath =
      resolve_paths(is_asan ? std::vector<std::string>({ "/data", "/system" }) :
                              std::vector<std::string>({ "/system/lib" ARCH_SUFFIX }));

  const std::vector<std::string> kExpectedVndkSearchPath =
      resolve_paths(is_asan ? std::vector<std::string>({ "/data", "/system/lib" ARCH_SUFFIX "/vndk"}) :
                              std::vector<std::string>({ "/system/lib" ARCH_SUFFIX "/vndk"}));

  TemporaryFile tmp_file;
  close(tmp_file.fd);
  tmp_file.fd = -1;

  android::base::WriteStringToFile(config_str, tmp_file.path);

  TemporaryDir tmp_dir;

  std::string executable_path = std::string(tmp_dir.path) + "/some-binary";
  std::string version_file = std::string(tmp_dir.path) + "/.version";

  auto file_guard =
      android::base::make_scope_guard([&version_file] { unlink(version_file.c_str()); });

  ASSERT_TRUE(write_version(version_file, 113U)) << strerror(errno);

  // read config
  const Config* config = nullptr;
  std::string error_msg;
  ASSERT_TRUE(Config::read_binary_config(tmp_file.path,
                                         executable_path.c_str(),
                                         is_asan,
                                         &config,
                                         &error_msg)) << error_msg;
  ASSERT_TRUE(config != nullptr);
  ASSERT_TRUE(error_msg.empty());

  ASSERT_EQ(113U, config->target_sdk_version());

  const NamespaceConfig* default_ns_config = config->default_namespace_config();
  ASSERT_TRUE(default_ns_config != nullptr);

  ASSERT_TRUE(default_ns_config->isolated());
  ASSERT_FALSE(default_ns_config->visible());
  ASSERT_EQ(kExpectedDefaultSearchPath, default_ns_config->search_paths());
  ASSERT_EQ(kExpectedDefaultPermittedPath, default_ns_config->permitted_paths());

  const auto& default_ns_links = default_ns_config->links();
  ASSERT_EQ(2U, default_ns_links.size());

  ASSERT_EQ("system", default_ns_links[0].ns_name());
  ASSERT_EQ("libc.so:libm.so:libdl.so:libstdc++.so", default_ns_links[0].shared_libs());
  ASSERT_FALSE(default_ns_links[0].allow_all_shared_libs());

  ASSERT_EQ("vndk", default_ns_links[1].ns_name());
  ASSERT_EQ("libcutils.so:libbase.so", default_ns_links[1].shared_libs());
  ASSERT_FALSE(default_ns_links[1].allow_all_shared_libs());

  auto& ns_configs = config->namespace_configs();
  ASSERT_EQ(3U, ns_configs.size());

  // find second namespace
  const NamespaceConfig* ns_system = nullptr;
  const NamespaceConfig* ns_vndk = nullptr;
  for (auto& ns : ns_configs) {
    std::string ns_name = ns->name();
    ASSERT_TRUE(ns_name == "system" || ns_name == "default" || ns_name == "vndk")
        << "unexpected ns name: " << ns->name();

    if (ns_name == "system") {
      ns_system = ns.get();
    } else if (ns_name == "vndk") {
      ns_vndk = ns.get();
    }
  }

  ASSERT_TRUE(ns_system != nullptr) << "system namespace was not found";

  ASSERT_TRUE(ns_system->isolated());
  ASSERT_TRUE(ns_system->visible());
  ASSERT_EQ(kExpectedSystemSearchPath, ns_system->search_paths());
  ASSERT_EQ(kExpectedSystemPermittedPath, ns_system->permitted_paths());

  ASSERT_TRUE(ns_vndk != nullptr) << "vndk namespace was not found";

  ASSERT_FALSE(ns_vndk->isolated()); // malformed bool property
  ASSERT_FALSE(ns_vndk->visible()); // undefined bool property
  ASSERT_EQ(kExpectedVndkSearchPath, ns_vndk->search_paths());

  const auto& ns_vndk_links = ns_vndk->links();
  ASSERT_EQ(1U, ns_vndk_links.size());
  ASSERT_EQ("default", ns_vndk_links[0].ns_name());
  ASSERT_TRUE(ns_vndk_links[0].allow_all_shared_libs());
}
示例#9
0
文件: main.c 项目: NeverMore93/INTANG
void initialize()
{
    time_t now = time(NULL);

    srand(now);

    startup_ts = now;

    if (init_log() == -1) {
        fprintf(stderr, "Failed to initialzie log module.\n");
        exit(EXIT_FAILURE);
    }

    int ver = read_version();
    if (ver < VERSION) {
        log_info("Previous version %d, current version %d", ver, VERSION); 
        // this is a version update! 
        if (need_to_delete_redis_db) {
            log_info("Deleting redis DB due to version update.");
            delete_redis_db();
        }
    }
    else
        log_info("Current version: %d", VERSION);
    write_version(VERSION);

    start_redis_server();

    if (init_socket() == -1) {
        log_error("Failed to initialize socket module.");
        exit(EXIT_FAILURE);
    }

    log_debug("Adding iptables rules.");
    if (add_iptables_rules() == -1) {
        log_error("Failed to add iptables rules.");
        exit(EXIT_FAILURE);
    }

    register_signal_handlers();

    if (setup_nfq() == -1) {
        log_error("unable to setup netfilter_queue");
        exit(EXIT_FAILURE);
    }

    log_debug("Init DNS client.");
    if (init_dns_cli() == -1) {
        log_error("Failed to initialize DNS module");
        exit(EXIT_FAILURE);
    }

    log_debug("Init ev watchers.");
    init_ev_watchers();

    // Begin to intercept packets 
    //if (setup_strategy() == -1) {
    //    log_error("Failed to setup strategy");
    //    exit(EXIT_FAILURE);
    //}
    
    log_debug("Loading TTL from file.");
    load_ttl_from_file("ttl");

    // start a debug thread
    //pthread_t thread_dbg;
    //if (pthread_create(&thread_dbg, NULL, debug_main, NULL) != 0) {
    //    log_error("Fail to create debug thread.");
    //    exit(EXIT_FAILURE);
    //}

    // start a thread to handle communications with redis
    pthread_t thread_cache;
    if (pthread_create(&thread_cache, NULL, cache_main, NULL) != 0){
        log_error("Fail to create caching thread.");
        exit(EXIT_FAILURE);
    }
    
    // start the DNS proxy thread
    pthread_t thread_dns;
    if (pthread_create(&thread_dns, NULL, dns_main, NULL) != 0){
        log_error("Fail to create DNS thread.");
        exit(EXIT_FAILURE);
    }

    // Uploading diagnostic log is disabled. (2017.4.26) 
    // start a thread to send feedback log
    //pthread_t thread_fb;
    //if (pthread_create(&thread_fb, NULL, feedback_main, NULL) != 0){
    //    log_error("Fail to create feedback thread.");
    //    exit(EXIT_FAILURE);
    //}
}
示例#10
0
int
main(int argc, char *argv[])
{
  int i = 1;
  char *eptr = 0;
  int total_clars, clar_id;
  struct clar_entry_v2 clar;
  unsigned char *text = 0;
  size_t size = 0;

  program_name = os_GetBasename(argv[0]);

  if (argc <= 1) die("not enough parameters");

  if (!strcmp(argv[1], "--help")) {
    write_help();
  } else if (!strcmp(argv[1], "--version")) {
    write_version();
  }

  i = 1;
  while (i < argc) {
    if (!strcmp(argv[i], "-f")) {
      if (i + 1 >= argc) die("argument expected for `-f'");
      ejudge_xml_path = argv[i + 1];
      i += 2;
    } else if (!strcmp(argv[i], "--")) {
      i++;
      break;
    } else if (argv[i][0] == '-') {
      die("invalid option `%s'", argv[i]);
    } else {
      break;
    }
  }

#if defined EJUDGE_XML_PATH
  if (!ejudge_xml_path) ejudge_xml_path = EJUDGE_XML_PATH;
#endif /* EJUDGE_XML_PATH */
  if (!ejudge_xml_path) die("ejudge.xml path is not specified");
  if (!(config = ejudge_cfg_parse(ejudge_xml_path))) return 1;
  if (!config->contests_dir) die("<contests_dir> tag is not set!");
  if (contests_set_directory(config->contests_dir) < 0)
    die("contests directory is invalid");

  if (i >= argc) die("contest-id is expected");
  if (!argv[i][0]) die("contest-id is not specified");
  errno = 0;
  contest_id = strtol(argv[i], &eptr, 10);
  if (*eptr || errno || contest_id <= 0 || contest_id > EJ_MAX_CONTEST_ID)
    die("contest-id is invalid");
  i++;

  if (i >= argc) die("source plugin name is expected");
  src_plugin_name = argv[i];
  i++;

  if (i >= argc) die("destination plugin name is expected");
  dst_plugin_name = argv[i];
  i++;

  if (i < argc) die("extra parameters");
  if (!src_plugin_name || !*src_plugin_name) src_plugin_name = "file";
  if (!dst_plugin_name || !*dst_plugin_name) dst_plugin_name = "file";

  if (!strcmp(src_plugin_name, dst_plugin_name))
    die("plugins are the same");

  if (contests_get(contest_id, &cnts) < 0 || !cnts)
    die("cannot load contest %d", contest_id);

  if (!(src_clarlog = clar_init()))
    die("cannot open the source clarlog");
  if (!(dst_clarlog = clar_init()))
    die("cannot open the destination clarlog");

  if (clar_open(src_clarlog, config, cnts, 0, src_plugin_name, 0) < 0)
    die("cannot open the source clarlog");
  if (clar_open(dst_clarlog, config, cnts, 0, dst_plugin_name, 0) < 0)
    die("cannot open the destination clarlog");

  total_clars = clar_get_total(src_clarlog);
  for (clar_id = 0; clar_id < total_clars; clar_id++) {
    if (clar_get_record(src_clarlog, clar_id, &clar) < 0) continue;
    if (clar.id < 0) continue;
    if (!ej_uuid_is_nonempty(clar.uuid)) {
      ej_uuid_generate(&clar.uuid);
    }
    clar_put_record(dst_clarlog, clar_id, &clar);
    if (clar_get_raw_text(src_clarlog, clar_id, &text, &size) < 0) continue;
    clar_add_text(dst_clarlog, clar_id, &clar.uuid, text, size);
    xfree(text); text = 0; size = 0;
  }
  return 0;
}