Ejemplo n.º 1
1
void
open_file(const boost::filesystem::path & file)
{
	const std::string arg = fs::system_complete(file).normalize()._BOOST_FS_NATIVE();

	SHELLEXECUTEINFO ExecuteInfo;

	memset(&ExecuteInfo, 0, sizeof(ExecuteInfo));

	ExecuteInfo.cbSize       = sizeof(ExecuteInfo);
	ExecuteInfo.fMask        = 0;                
	ExecuteInfo.hwnd         = 0;                
	ExecuteInfo.lpVerb       = "open";                      // Operation to perform
	ExecuteInfo.lpFile       = "iexplore.exe"; //"c:\\windows\\notepad.exe";  // Application name
	ExecuteInfo.lpParameters = arg.c_str();           // Additional parameters
	ExecuteInfo.lpDirectory  = 0;                           // Default directory
	ExecuteInfo.nShow        = SW_SHOW;
	ExecuteInfo.hInstApp     = 0;

	if(ShellExecuteEx(&ExecuteInfo) == FALSE)
	{
		// Could not start application -> call 'GetLastError()'
		throw get_win_last_error();
	}

	log_stream()
		<< std::endl
		<< "If you have problems with the information bar in Internet Explorer,"
		<< std::endl
		<< "follow the instructions at:"
		<< std::endl
		<< "http://www.phdcc.com/xpsp2.htm#securityoptions"
		<< std::endl
		<< std::endl;

}
Ejemplo n.º 2
0
inline void tlog(const char *fmt, ...){
  if( !log_stream() )
    return;
  
  va_list argList;
  va_start(argList, fmt);

  const int BUFF_SIZES[]={1024, 16*1024, 64*1024, 256*1024, 1024*1024, 16*1024*1024};
  int buffCount=sizeof(BUFF_SIZES)/sizeof(BUFF_SIZES[0]);

  char *ret[]={0, 0, 0, 0, 0, 0};

  int buffSize=0;
  int err=-1;
  int buffIndex=0;
  for(; err==-1 && buffIndex < buffCount; ++buffIndex){
    buffSize=BUFF_SIZES[buffIndex];

    if(buffIndex!=0)
      delete[] ret[buffIndex-1];
    
    ret[buffIndex]=new char[buffSize];

    err=vsnprintf(ret[buffIndex], buffSize-1, fmt, argList);
  }
  fputs(ret[buffIndex-1], log_stream());
  delete[] ret[buffIndex-1];
}
Ejemplo n.º 3
0
    bool tearDownWorld(){
      tlog("\n\n" );
      tlog("//==========================================================\n" );
      tlog("//                       -=[ Log end ]=-                    \n" );
      tlog("//==========================================================\n" );

#if defined (N_LOG_FILE)
      fclose(log_stream());
#endif
      log_stream()=stdout;
      
      return true;
    }
/****************
 * Show the revocation reason as it is stored with the given signature
 */
static void
do_show_revocation_reason( PKT_signature *sig )
{
    size_t n, nn;
    const byte *p, *pp;
    int seq = 0;
    const char *text;

    while( (p = enum_sig_subpkt (sig->hashed, SIGSUBPKT_REVOC_REASON,
				 &n, &seq, NULL )) ) {
	if( !n )
	    continue; /* invalid - just skip it */

	if( *p == 0 )
	    text = _("No reason specified");
	else if( *p == 0x01 )
	    text = _("Key is superseded");
	else if( *p == 0x02 )
	    text = _("Key has been compromised");
	else if( *p == 0x03 )
	    text = _("Key is no longer used");
	else if( *p == 0x20 )
	    text = _("User ID is no longer valid");
	else
	    text = NULL;

	log_info( _("reason for revocation: ") );
	if( text )
	    fputs( text, log_stream() );
	else
	    fprintf( log_stream(), "code=%02x", *p );
	putc( '\n', log_stream() );
	n--; p++;
	pp = NULL;
	do {
	    /* We don't want any empty lines, so skip them */
	    while( n && *p == '\n' ) {
		p++;
		n--;
	    }
	    if( n ) {
		pp = memchr( p, '\n', n );
		nn = pp? pp - p : n;
		log_info( _("revocation comment: ") );
		print_string( log_stream(), p, nn, 0 );
		putc( '\n', log_stream() );
		p += nn; n -= nn;
	    }
	} while( pp );
    }
}
Ejemplo n.º 5
0
void
g10_log_mpidump( const char *text, MPI a )
{
    FILE *fp = log_stream();

    g10_log_print_prefix(text);
    mpi_print(fp, a, 1 );
    fputc('\n', fp);
}
Ejemplo n.º 6
0
 virtual Status logString(const std::string& s) {
   std::lock_guard<std::mutex> lock(filesystemLoggerPluginMutex);
   try {
     VLOG(3) << "filesystem logger plugin: logging to " << log_path;
     std::ofstream log_stream(log_path,
                              std::ios_base::app | std::ios_base::out);
     if (log_stream.fail()) {
       return Status(1, "error opening file: " + log_path);
     }
     log_stream << s;
   } catch (const std::exception& e) {
     return Status(1, e.what());
   }
   return Status(0, "OK");
 }
Ejemplo n.º 7
0
    nlohmann::json collection::evaluate_log(std::string const& log)
    {
        nlohmann::json json_log;
        std::istringstream log_stream(log);
        for(std::string line; std::getline(log_stream, line); ) {
            auto const delimiter = line.find_first_of(':');
            if(delimiter != std::string::npos) {
                std::string key = line.substr(0, delimiter);
                std::string val = line.substr(delimiter + 2);
                std::replace(key.begin(), key.end(), ' ', '_');
                std::transform(key.begin(), key.end(), key.begin(), ::tolower);
                nlohmann::json json_val;
                try {
                    json_val = boost::lexical_cast<long>(val);
                } catch(boost::bad_lexical_cast const& e) {
                    if(val == "YES") {
                        json_val = true;
                    } else if(val == "NO") {
                        json_val = false;
                    } else if(val == "'NONE'") {
                        json_val = nullptr;
                    } else {
                        size_t const bson_hex_delimiter = val.find_first_of('/');
                        if(bson_hex_delimiter != std::string::npos) {
                            std::string const bson_hex_string = val.substr(0, bson_hex_delimiter);
                            std::string bson_decoded_data;
                            boost::algorithm::unhex(bson_hex_string.begin(), bson_hex_string.end(), back_inserter(bson_decoded_data));
                            json_val = convert_to_json(std::shared_ptr<bson>(bson_create_from_buffer(bson_decoded_data.data(), bson_decoded_data.size()), bson_del));
                        } else {
                            json_val = val;
                        }
                    }
                }

                if(json_log.find(key) != json_log.end()) {
                    if(json_log[key].type() != nlohmann::json::value_t::array) {
                        json_log[key] = nlohmann::json::array_t({ json_log[key] });
                    }
                    json_log[key].push_back(json_val);
                } else {
                    json_log[key] = json_val;

                }
            }
        }
        return json_log;
    }
Ejemplo n.º 8
0
PAL_HANDLE
DkProcessCreate (PAL_STR uri, PAL_FLG flags, PAL_STR * args)
{
    ENTER_PAL_CALL(DkProcessCreate);

    log_stream(uri);

    PAL_HANDLE handle = NULL;
    int ret = _DkProcessCreate(&handle, uri, flags, args);

    if (ret < 0) {
        _DkRaiseFailure(-ret);
        handle = NULL;
    }

    LEAVE_PAL_CALL_RETURN(handle);
}
Ejemplo n.º 9
0
QString UDDBusServer::getLastMessagesLines(int lines_count){
  QFile log("/var/log/messages");
  log.open(QIODevice::ReadOnly);
  QTextStream log_stream(&log);
  QString line;
  QStringList last_lines;
  int current_count = 0;
  while (!log_stream.atEnd()){
    line = log_stream.readLine();
    last_lines.push_back(line);
    if (current_count >= lines_count)
      last_lines.pop_front();
    else
      current_count++;
  }
  log.close();
  QString result;
  result = last_lines.join("\n");
  return result;
}
Ejemplo n.º 10
0
    bool setUpWorld(){
      const char *logOut="stdout";
#if defined(N_LOG_FILE)
      // log to file
      logOut=N_LOG_FILE;
      log_stream()=fopen(logOut, "w");
#else
      // log to stdout.
      tlog("\n");
#endif
      time_t curr=time(NULL);
      tlog("//==========================================================\n"
           "/**\n"
           " \\file         %s\n"
           " \\date:        %s"
           "*/\n"
           "//==========================================================\n",
           logOut,
           ctime(&curr)
           );
      return true;
    }
Ejemplo n.º 11
0
static int
get_it( PKT_pubkey_enc *enc, DEK *dek, PKT_secret_key *sk, u32 *keyid )
{
  int rc;
  MPI plain_dek  = NULL;
  byte *frame = NULL;
  unsigned n, nframe;
  u16 csum, csum2;
  
  int card = 0;

  if (sk->is_protected && sk->protect.s2k.mode == 1002)
    { /* Note, that we only support RSA for now. */
#ifdef ENABLE_CARD_SUPPORT
      unsigned char *rbuf;
      size_t rbuflen;
      char *snbuf;
      unsigned char *indata = NULL;
      unsigned int indatalen;

      snbuf = serialno_and_fpr_from_sk (sk->protect.iv, sk->protect.ivlen, sk);

      indata = mpi_get_buffer (enc->data[0], &indatalen, NULL);
      if (!indata)
        BUG ();

      rc = agent_scd_pkdecrypt (snbuf, indata, indatalen, &rbuf, &rbuflen);
      xfree (snbuf);
      xfree (indata);
      if (rc)
        goto leave;

      frame = rbuf;
      nframe = rbuflen;
      card = 1;
#else
      rc = G10ERR_UNSUPPORTED;
      goto leave;
#endif /*!ENABLE_CARD_SUPPORT*/
    }
  else
    {
      rc = pubkey_decrypt(sk->pubkey_algo, &plain_dek, enc->data, sk->skey );
      if( rc )
	goto leave;
      frame = mpi_get_buffer( plain_dek, &nframe, NULL );
      mpi_free( plain_dek ); plain_dek = NULL;
    }

    /* Now get the DEK (data encryption key) from the frame
     *
     * Old versions encode the DEK in in this format (msb is left):
     *
     *	   0  1  DEK(16 bytes)	CSUM(2 bytes)  0  RND(n bytes) 2
     *
     * Later versions encode the DEK like this:
     *
     *	   0  2  RND(n bytes)  0  A  DEK(k bytes)  CSUM(2 bytes)
     *
     * (mpi_get_buffer already removed the leading zero).
     *
     * RND are non-zero randow bytes.
     * A   is the cipher algorithm
     * DEK is the encryption key (session key) with length k
     * CSUM
     */
    if( DBG_CIPHER )
	log_hexdump("DEK frame:", frame, nframe );
    n=0;
    if (!card)
      {
        if( n + 7 > nframe )
          { rc = G10ERR_WRONG_SECKEY; goto leave; }
        if( frame[n] == 1 && frame[nframe-1] == 2 ) {
          log_info(_("old encoding of the DEK is not supported\n"));
          rc = G10ERR_CIPHER_ALGO;
          goto leave;
        }
        if( frame[n] != 2 )  /* somethink is wrong */
          { rc = G10ERR_WRONG_SECKEY; goto leave; }
        for(n++; n < nframe && frame[n]; n++ ) /* skip the random bytes */
          ;
        n++; /* and the zero byte */
      }

    if( n + 4 > nframe )
	{ rc = G10ERR_WRONG_SECKEY; goto leave; }

    dek->keylen = nframe - (n+1) - 2;
    dek->algo = frame[n++];
    if( dek->algo ==  CIPHER_ALGO_IDEA )
	write_status(STATUS_RSA_OR_IDEA);
    rc = check_cipher_algo( dek->algo );
    if( rc ) {
	if( !opt.quiet && rc == G10ERR_CIPHER_ALGO ) {
	    log_info(_("cipher algorithm %d%s is unknown or disabled\n"),
                     dek->algo, dek->algo == CIPHER_ALGO_IDEA? " (IDEA)":"");
	    if(dek->algo==CIPHER_ALGO_IDEA)
	      idea_cipher_warn(0);
	}
	dek->algo = 0;
	goto leave;
    }
    if( (dek->keylen*8) != cipher_get_keylen( dek->algo ) ) {
	rc = G10ERR_WRONG_SECKEY;
	goto leave;
    }

    /* copy the key to DEK and compare the checksum */
    csum  = frame[nframe-2] << 8;
    csum |= frame[nframe-1];
    memcpy( dek->key, frame+n, dek->keylen );
    for( csum2=0, n=0; n < dek->keylen; n++ )
	csum2 += dek->key[n];
    if( csum != csum2 ) {
	rc = G10ERR_WRONG_SECKEY;
	goto leave;
    }
    if( DBG_CIPHER )
	log_hexdump("DEK is:", dek->key, dek->keylen );
    /* check that the algo is in the preferences and whether it has expired */
    {
	PKT_public_key *pk = NULL;
        KBNODE pkb = get_pubkeyblock (keyid);

	if( !pkb ) {
            rc = -1;
	    log_error("oops: public key not found for preference check\n");
        }
	else if(pkb->pkt->pkt.public_key->selfsigversion > 3
		&& dek->algo != CIPHER_ALGO_3DES
		&& !opt.quiet
		&& !is_algo_in_prefs( pkb, PREFTYPE_SYM, dek->algo ))
	  log_info(_("WARNING: cipher algorithm %s not found in recipient"
		     " preferences\n"),cipher_algo_to_string(dek->algo));
        if (!rc) {
            KBNODE k;
            
            for (k=pkb; k; k = k->next) {
                if (k->pkt->pkttype == PKT_PUBLIC_KEY 
                    || k->pkt->pkttype == PKT_PUBLIC_SUBKEY){
                    u32 aki[2];
        	    keyid_from_pk(k->pkt->pkt.public_key, aki);

                    if (aki[0]==keyid[0] && aki[1]==keyid[1]) {
                        pk = k->pkt->pkt.public_key;
                        break;
                    }
                }
            }
            if (!pk)
                BUG ();
            if ( pk->expiredate && pk->expiredate <= make_timestamp() ) {
                log_info(_("NOTE: secret key %s expired at %s\n"),
                         keystr(keyid), asctimestamp( pk->expiredate) );
            }
        }

        if ( pk &&  pk->is_revoked ) {
            log_info( _("NOTE: key has been revoked") );
            putc( '\n', log_stream() );
            show_revocation_reason( pk, 1 );
        }

	release_kbnode (pkb);
	rc = 0;
    }


  leave:
    mpi_free(plain_dek);
    xfree(frame);
    return rc;
}
Ejemplo n.º 12
0
Archivo: log.cpp Proyecto: LeDYoM/Zoper
void print_impl()
{
	log_stream() << '\n';
	commitLog();
}
Ejemplo n.º 13
0
int     main(int argc, char **argv)
{
    struct stat st;
    char   *slash;
    int     fd;
    int     ch;
    const char *tag;
    int     log_flags = 0;
    int     level = MSG_INFO;

    /*
     * Fingerprint executables and core dumps.
     */
    MAIL_VERSION_STAMP_ALLOCATE;

    /*
     * Be consistent with file permissions.
     */
    umask(022);

    /*
     * To minimize confusion, make sure that the standard file descriptors
     * are open before opening anything else. XXX Work around for 44BSD where
     * fstat can return EBADF on an open file descriptor.
     */
    for (fd = 0; fd < 3; fd++)
	if (fstat(fd, &st) == -1
	    && (close(fd), open("/dev/null", O_RDWR, 0)) != fd)
	    msg_fatal("open /dev/null: %m");

    /*
     * Set up diagnostics.
     */
    if ((slash = strrchr(argv[0], '/')) != 0 && slash[1])
	tag = mail_task(slash + 1);
    else
	tag = mail_task(argv[0]);
    if (isatty(STDERR_FILENO))
	msg_vstream_init(tag, VSTREAM_ERR);
    msg_syslog_init(tag, LOG_PID, LOG_FACILITY);

    /*
     * Check the Postfix library version as soon as we enable logging.
     */
    MAIL_VERSION_CHECK;

    /*
     * Parse switches.
     */
    while ((ch = GETOPT(argc, argv, "c:ip:t:v")) > 0) {
	switch (ch) {
	default:
	    msg_fatal("usage: %s [-c config_dir] [-i] [-p priority] [-t tag] [-v] [text]", tag);
	    break;
	case 'c':
	    if (setenv(CONF_ENV_PATH, optarg, 1) < 0)
		msg_fatal("out of memory");
	    break;
	case 'i':
	    log_flags |= LOG_PID;
	    break;
	case 'p':
	    level = level_map(optarg);
	    break;
	case 't':
	    tag = optarg;
	    break;
	case 'v':
	    msg_verbose++;
	    break;
	}
    }

    /*
     * Process the main.cf file. This overrides any logging facility that was
     * specified with msg_syslog_init();
     */
    mail_conf_read();
    if (tag == 0 && strcmp(var_syslog_name, DEF_SYSLOG_NAME) != 0) {
	if ((slash = strrchr(argv[0], '/')) != 0 && slash[1])
	    tag = mail_task(slash + 1);
	else
	    tag = mail_task(argv[0]);
    }

    /*
     * Re-initialize the logging, this time with the tag specified in main.cf
     * or on the command line.
     */
    if (tag != 0) {
	if (isatty(STDERR_FILENO))
	    msg_vstream_init(tag, VSTREAM_ERR);
	msg_syslog_init(tag, LOG_PID, LOG_FACILITY);
    }

    /*
     * Log the command line or log lines from standard input.
     */
    if (argc > optind) {
	log_argv(level, argv + optind);
    } else {
	log_stream(level, VSTREAM_IN);
    }
    exit(0);
}
Ejemplo n.º 14
0
void UnitTestOutputLog::testUnit()
{
  // Make cout and cerr available as log stream targets.
  stk::register_log_ostream(std::cout, "cout");
  stk::register_log_ostream(std::cerr, "cerr");

  // Test registration, binding, rebinding and unregistration
  {
    std::ostringstream log1;
    std::ostringstream log2;
    
    std::ostream out(std::cout.rdbuf());

    stk::register_ostream(out, "out");

    CPPUNIT_ASSERT(stk::is_registered_ostream("out"));
    
    stk::register_log_ostream(log1, "log1");
    stk::register_log_ostream(log2, "log2");

    stk::bind_output_streams("out>log1");

    out << "stk::bind_output_streams(\"out>log1\");" << std::endl;

    stk::bind_output_streams("out>+log2");
    out << "stk::bind_output_streams(\"out>+log2\");" << std::endl;
    
    stk::bind_output_streams("out>-log1");
    out << "stk::bind_output_streams(\"out>-log1\");" << std::endl;

    stk::bind_output_streams("out>-log2");
    out << "stk::bind_output_streams(\"out>-log2\");" << std::endl;

    std::ostringstream log1_result;
    log1_result << "stk::bind_output_streams(\"out>log1\");" << std::endl
                << "stk::bind_output_streams(\"out>+log2\");" << std::endl;
    
    std::ostringstream log2_result;
    log2_result << "stk::bind_output_streams(\"out>+log2\");" << std::endl
                << "stk::bind_output_streams(\"out>-log1\");" << std::endl;
    
    CPPUNIT_ASSERT_EQUAL(log1_result.str(), log1.str());
    CPPUNIT_ASSERT_EQUAL(log2_result.str(), log2.str());

    stk::unregister_log_ostream(log1);
    stk::unregister_log_ostream(log2);
    stk::unregister_ostream(out);

    CPPUNIT_ASSERT_EQUAL(out.rdbuf(), std::cout.rdbuf());
  }

  // Test logging to a file
  {
    std::ostream out(std::cout.rdbuf());

    stk::register_ostream(out, "out");

    stk::bind_output_streams("log=\"logfile\" out>log");

    CPPUNIT_ASSERT_EQUAL(std::string("logfile"), stk::get_log_path("log")); 
    
    out << "This is a test" << std::endl;

    stk::bind_output_streams("log=\"\"");
    
    stk::unregister_ostream(out);

    std::ostringstream log_result;
    log_result << "This is a test";
    
    std::ifstream log_stream("logfile");
    std::string log_string;
    getline(log_stream, log_string);
    CPPUNIT_ASSERT_EQUAL(log_result.str(), log_string);
  }

  // Test results of unregistration of an output stream bound as a log stream
  {
    std::ostringstream default_log;
    std::ostream out(default_log.rdbuf());
    std::ostream pout(std::cout.rdbuf());

    stk::register_ostream(out, "out");
    stk::register_ostream(pout, "pout");

    //  Constructing the log streams after the registered output stream is not exception safe.
    std::ostringstream log;
    stk::register_log_ostream(log, "log");

    // As a result, this try catch block must be represent to ensure the that unregistration
    // happens correctly.
    try {  
      stk::bind_output_streams("out>pout pout>log");

      out << "This is to out" << std::endl;
      pout << "This is to pout" << std::endl;

      std::ostringstream log_result;
      log_result << "This is to out" << std::endl
                 << "This is to pout" << std::endl;
    
      CPPUNIT_ASSERT_EQUAL(log_result.str(), log.str());

      throw std::exception();
    }
    catch (...) {
    }

    stk::unregister_log_ostream(log);
    stk::unregister_ostream(pout);
    stk::unregister_ostream(out);

    out << "This is to out" << std::endl;

    std::ostringstream log_result;
    log_result << "This is to out" << std::endl;
    CPPUNIT_ASSERT_EQUAL(log_result.str(), default_log.str());
  }

  // Test exception of registration with existing name
  {
    std::ostringstream log1;
    std::ostringstream log2;
    
    std::ostream out(std::cout.rdbuf());
    std::ostream pout(std::cout.rdbuf());

    stk::register_ostream(out, "out");
    CPPUNIT_ASSERT_THROW(stk::register_ostream(pout, "out"), std::runtime_error);

    CPPUNIT_ASSERT_EQUAL(&out, stk::get_ostream_ostream("out"));

    stk::register_log_ostream(log1, "log");
    
    CPPUNIT_ASSERT_THROW(stk::register_log_ostream(log2, "log"), std::runtime_error);

    CPPUNIT_ASSERT_THROW(stk::bind_output_streams("badout>log"), std::runtime_error);
    
    CPPUNIT_ASSERT_THROW(stk::bind_output_streams("out>badlog"), std::runtime_error);

    stk::unregister_log_ostream(log1);
    stk::unregister_ostream(out);
  }
}