Esempio n. 1
0
static void write_value(io::stream& e, const void* object, const bsreq* req, int level) {
	if(req->type == number_type) {
		auto value = req->get(object);
		e << value;
	} else if(req->type == text_type) {
		auto value = (const char*)req->get(object);
		e << "\"" << value << "\"";
	} else if(req->reference) {
		auto value = (const void*)req->get(object);
		write_key(e, value, req->type);
	} else if(req->isenum) {
		auto value = req->get(object);
		auto pd = bsdata::find(req->type);
		if(pd)
			write_key(e, pd->get(value), req->type);
		else
			e << value;
	} else {
		if(level > 0)
			e << "(";
		auto count = 0;
		for(auto f = req->type; *f; f++) {
			if(count)
				e << ", ";
			write_array(e, object, f, level + 1);
			count++;
		}
		if(level > 0)
			e << ")";
	}
}
Esempio n. 2
0
static bool_t audpl_save (const char * path, VFSFile * file,
 const char * title, Index * filenames, Index * tuples)
{
    if (! write_key (file, "title", title))
        return FALSE;

    int count = index_count (filenames);

    for (int i = 0; i < count; i ++)
    {
        if (! write_key (file, "uri", index_get (filenames, i)))
            return FALSE;

        const Tuple * tuple = tuples ? index_get (tuples, i) : NULL;

        if (tuple)
        {
            int keys = 0;

            for (int f = 0; f < TUPLE_FIELDS; f ++)
            {
                if (f == FIELD_FILE_PATH || f == FIELD_FILE_NAME || f == FIELD_FILE_EXT)
                    continue;

                TupleValueType type = tuple_get_value_type (tuple, f, NULL);

                if (type == TUPLE_STRING)
                {
                    char * str = tuple_get_str (tuple, f, NULL);

                    if (! write_key (file, tuple_field_get_name (f), str))
                    {
                        str_unref (str);
                        return FALSE;
                    }

                    str_unref (str);
                    keys ++;
                }
                else if (type == TUPLE_INT)
                {
                    char buf[32];
                    snprintf (buf, sizeof buf, "%d", tuple_get_int (tuple, f, NULL));

                    if (! write_key (file, tuple_field_get_name (f), buf))
                        return FALSE;

                    keys ++;
                }
            }

            /* distinguish between an empty tuple and no tuple at all */
            if (! keys && ! write_key (file, "empty", "1"))
                return FALSE;
        }
    }

    return TRUE;
}
Esempio n. 3
0
gboolean
ostree_bootconfig_parser_write (OstreeBootconfigParser   *self,
                                GFile            *output,
                                GCancellable     *cancellable,
                                GError          **error)
{
  gboolean ret = FALSE;
  GHashTableIter hashiter;
  gpointer hashkey, hashvalue;
  GString *buf = g_string_new ("");
  gs_unref_bytes GBytes *bytes = NULL;
  guint i;
  gs_unref_hashtable GHashTable *written_overrides = NULL;

  written_overrides = g_hash_table_new (g_str_hash, g_str_equal);

  for (i = 0; i < self->lines->len; i++)
    {
      GVariant *linedata = self->lines->pdata[i];
      const char *key;
      const char *value;
      const char *line;

      g_variant_get (linedata, "(&s&s)", &key, &line);

      value = g_hash_table_lookup (self->options, key);
      if (value == NULL)
        {
          g_string_append (buf, line);
          g_string_append_c (buf, '\n');
        }
      else
        {
          write_key (self, buf, key, value);
          g_hash_table_insert (written_overrides, (gpointer)key, (gpointer)key);
        }
    }

  g_hash_table_iter_init (&hashiter, self->options);
  while (g_hash_table_iter_next (&hashiter, &hashkey, &hashvalue))
    {
      if (g_hash_table_lookup (written_overrides, hashkey))
        continue;
      write_key (self, buf, hashkey, hashvalue);
    }

  bytes = g_string_free_to_bytes (buf);
  buf = NULL;

  if (!ot_gfile_replace_contents_fsync (output, bytes,
                                        cancellable, error))
    goto out;

  ret = TRUE;
 out:
  if (buf) g_string_free (buf, TRUE);
  return ret;
}
Esempio n. 4
0
gboolean
ostree_bootconfig_parser_write_at (OstreeBootconfigParser   *self,
                                   int                       dfd,
                                   const char               *path,
                                   GCancellable             *cancellable,
                                   GError                  **error)
{
  gboolean ret = FALSE;
  GHashTableIter hashiter;
  gpointer hashkey, hashvalue;
  GString *buf = g_string_new ("");
  guint i;
  g_autoptr(GHashTable) written_overrides = NULL;

  written_overrides = g_hash_table_new (g_str_hash, g_str_equal);

  for (i = 0; i < self->lines->len; i++)
    {
      GVariant *linedata = self->lines->pdata[i];
      const char *key;
      const char *value;
      const char *line;

      g_variant_get (linedata, "(&s&s)", &key, &line);

      value = g_hash_table_lookup (self->options, key);
      if (value == NULL)
        {
          g_string_append (buf, line);
          g_string_append_c (buf, '\n');
        }
      else
        {
          write_key (self, buf, key, value);
          g_hash_table_add (written_overrides, (gpointer)key);
        }
    }

  g_hash_table_iter_init (&hashiter, self->options);
  while (g_hash_table_iter_next (&hashiter, &hashkey, &hashvalue))
    {
      if (g_hash_table_lookup (written_overrides, hashkey))
        continue;
      write_key (self, buf, hashkey, hashvalue);
    }

  if (!glnx_file_replace_contents_at (dfd, path, (guint8*)buf->str, buf->len,
                                      GLNX_FILE_REPLACE_NODATASYNC,
                                      cancellable, error))
    goto out;

  ret = TRUE;
 out:
  if (buf)
    g_string_free (buf, TRUE);
  return ret;
}
// Step #3: execute keystroke sequence
//
void usb_keyboard_class::write_keycode(KEYCODE_TYPE keycode)
{
	if (!keycode) return;
	#ifdef DEADKEYS_MASK
	KEYCODE_TYPE deadkeycode = deadkey_to_keycode(keycode);
	if (deadkeycode) write_key(deadkeycode);
	#endif
	write_key(keycode);
}
void usb_keyboard_write_unicode(uint16_t cpoint)
{
	KEYCODE_TYPE keycode;

	keycode = unicode_to_keycode(cpoint);
	if (keycode) {
		#ifdef DEADKEYS_MASK
		KEYCODE_TYPE deadkeycode = deadkey_to_keycode(keycode);
		if (deadkeycode) write_key(deadkeycode);
		#endif
		write_key(keycode);
	}
}
Esempio n. 7
0
int newagent::account(const char * user,
                      const char * password)
{ int res=0;
#ifdef _WIN32
  if (user)              write_key("01",(LPBYTE)user,strlen((char*)user)+1);
  if (password)          write_key("02",(LPBYTE)password,strlen((char*)password)+1);
  unmap_drive();
  CloseHandle(server_user);
  server_user=0;
  logon(res);
#endif
  return res;
}
Esempio n. 8
0
// Step #3: execute keystroke sequence
//
void usb_keyboard_class::write_keycode(KEYCODE_TYPE key)
{
	if (!key) return;
	#ifdef DEADKEYS_MASK
	KEYCODE_TYPE deadkey = key & DEADKEYS_MASK;
	#ifdef ACUTE_ACCENT_BITS
	if (deadkey == ACUTE_ACCENT_BITS) write_key(DEADKEY_ACUTE_ACCENT);
	#endif
	#ifdef CEDILLA_BITS
	if (deadkey == CEDILLA_BITS) write_key(DEADKEY_CEDILLA);
	#endif
	#ifdef CIRCUMFLEX_BITS
	if (deadkey == CIRCUMFLEX_BITS) write_key(DEADKEY_CIRCUMFLEX);
	#endif
	#ifdef DIAERESIS_BITS
	if (deadkey == DIAERESIS_BITS) write_key(DEADKEY_DIAERESIS);
	#endif
	#ifdef GRAVE_ACCENT_BITS
	if (deadkey == GRAVE_ACCENT_BITS) write_key(DEADKEY_GRAVE_ACCENT);
	#endif
	#ifdef TILDE_BITS
	if (deadkey == TILDE_BITS) write_key(DEADKEY_TILDE);
	#endif
	#ifdef RING_ABOVE_BITS
	if (deadkey == RING_ABOVE_BITS) write_key(DEADKEY_RING_ABOVE);
	#endif
	#endif // DEADKEYS_MASK
	write_key(key);
}
Esempio n. 9
0
/* \brief Private helper. Common code for writing OBJECT & ARRAY signatures
 *
 * \param writer binson_writer*       Context
 * \param key const char*             Optional key. Use NULL to output ARRAY items
 * \param sig uint8_t                 Signature to specify type of OBJECT
 * \return binson_res                 Result code
 */
binson_res  write_frame_sig( binson_writer *writer, const char* key, uint8_t sig  )
{
  binson_res res = BINSON_RES_OK;

  /* Initial parameter validation */
  if (!writer)
    return BINSON_RES_ERROR_ARG_WRONG;

#ifdef WITH_BINSON_JSON_OUTPUT
 if (sig == BINSON_SIG_OBJ_END || sig == BINSON_SIG_ARRAY_END)
  {
    writer->depth--;
    writer->idx_stack[writer->depth]++;
  }
#endif

  /* write key if needed */
  res = write_key( writer, key, (sig == BINSON_SIG_OBJ_END || sig == BINSON_SIG_ARRAY_END)? true : false );
  if (FAILED(res)) return res;

#ifdef WITH_BINSON_JSON_OUTPUT
  /* Updating tracking vars for new nesting level */
  if (sig == BINSON_SIG_OBJ_BEGIN || sig == BINSON_SIG_ARRAY_BEGIN)
  {
    writer->sig_stack[writer->depth] = sig;
    writer->depth++;
    writer->idx_stack[writer->depth] = 0;
  }
  else
  if (sig != BINSON_SIG_OBJ_END && sig != BINSON_SIG_ARRAY_END)
  {
    writer->idx_stack[writer->depth]++;
  }
#endif

  switch (writer->format)
  {
    case BINSON_WRITER_FORMAT_RAW:
      res = binson_io_write_byte( writer->io, sig );
    break;

    case BINSON_WRITER_FORMAT_HEX:
      res = binson_io_printf(writer->io, "%02x \n", sig );
    break;

#ifdef WITH_BINSON_JSON_OUTPUT
    case BINSON_WRITER_FORMAT_JSON:
    case BINSON_WRITER_FORMAT_JSON_NICE:
      res = binson_io_write_str( writer->io, sig == BINSON_SIG_OBJ_BEGIN? "{ ": (sig == BINSON_SIG_OBJ_END? "} " :
                                            (sig == BINSON_SIG_ARRAY_BEGIN? "[ " : (sig == BINSON_SIG_ARRAY_END? "] " : " "))), true );
      if (FAILED(res)) return res;
    break;
#endif

    default:
      return BINSON_RES_ERROR_ARG_WRONG;
  }

  return res;
}
Esempio n. 10
0
// Step #2: translate Unicode code point to keystroke sequence
//
void usb_keyboard_class::write_unicode(uint16_t cpoint)
{
	// Unicode code points beyond U+FFFF are not supported
	// technically this input should probably be called UCS-2
	if (cpoint < 32) {
		if (cpoint == 10) write_key(KEY_ENTER);
		return;
	}
	if (cpoint < 128) {
		if (sizeof(KEYCODE_TYPE) == 1) {
			write_keycode(pgm_read_byte(keycodes_ascii + (cpoint - 0x20)));
		} else if (sizeof(KEYCODE_TYPE) == 2) {
			write_keycode(pgm_read_word(keycodes_ascii + (cpoint - 0x20)));
		}
		return;
	}
	#ifdef ISO_8859_1_A0
	if (cpoint <= 0xA0) return;
	if (cpoint < 0x100) {
		if (sizeof(KEYCODE_TYPE) == 1) {
			write_keycode(pgm_read_byte(keycodes_iso_8859_1 + (cpoint - 0xA0)));
		} else if (sizeof(KEYCODE_TYPE) == 2) {
			write_keycode(pgm_read_word(keycodes_iso_8859_1 + (cpoint - 0xA0)));
		}
		return;
	}
	#endif
	#ifdef UNICODE_20AC
		if (cpoint == 0x20AC) write_keycode(UNICODE_20AC);
	#endif
}
Esempio n. 11
0
/** \brief Write output to io for single \c int8_t .. \c int64_t value
 *         with automatic type downgrade according to real bytes used
 *
 * \param writer binson_writer*   Context
 * \param key const char*         Optional key. Use NULL to output ARRAY items
 * \param val int64_t             Integer argument
 * \return binson_res             Result code
 */
binson_res  binson_writer_write_integer( binson_writer *writer, const char* key, int64_t val )
{
  const uint8_t binson_int_map[] = { BINSON_SIG_INTEGER_8,      /* for 0 bytes of int data */
                                     BINSON_SIG_INTEGER_8,      /* for 1 bytes of int data */
                                     BINSON_SIG_INTEGER_16,     /* for 2 bytes of int data */
                                     BINSON_SIG_INTEGER_32,     /* for 3 bytes of int data */
                                     BINSON_SIG_INTEGER_32,     /* for 4 bytes of int data */
                                     BINSON_SIG_INTEGER_64,     /* for 5 bytes of int data */
                                     BINSON_SIG_INTEGER_64,     /* for 6 bytes of int data */
                                     BINSON_SIG_INTEGER_64,     /* for 7 bytes of int data */
                                     BINSON_SIG_INTEGER_64 };   /* for 8 bytes of int data */
  binson_res  res = BINSON_RES_OK;
  uint8_t     bbuf[sizeof(int64_t)+1] = {0,0,0,0,0,0,0,0,0}; /* this initialization prevents aggressive optimization from breaking the code */
  size_t     bsize;
  unsigned int         i;

  /* Initial parameter validation */
  if (!writer)
    return BINSON_RES_ERROR_ARG_WRONG;

  /* write key if needed */
  res = write_key( writer, key, false );
  if (FAILED(res)) return res;

#ifdef WITH_BINSON_JSON_OUTPUT
  writer->idx_stack[writer->depth]++;
#endif

  /* Convert value to INTEGER primitive and store it in specified byte buffer */
  bsize = binson_util_pack_integer( val, &bbuf[1] );
  bbuf[0] = binson_int_map[bsize];

  /* Format dependent output */
  switch (writer->format)
  {
    case BINSON_WRITER_FORMAT_RAW:
      res = binson_io_write( writer->io, bbuf, bsize+1 );
      break;

    case BINSON_WRITER_FORMAT_HEX:
      for (i=0; i<bsize+1; i++)
        res = binson_io_printf( writer->io, "%02x ", bbuf[i] );
      res = binson_io_write_str( writer->io, "\n", true );
      break;

#ifdef WITH_BINSON_JSON_OUTPUT
    case BINSON_WRITER_FORMAT_JSON:
    case BINSON_WRITER_FORMAT_JSON_NICE:
      res = binson_io_printf( writer->io, "%ld", val );    /* \todo fix printing int64_t in C89 */
      if (FAILED(res)) return res;
    break;
#endif

    default:
      return BINSON_RES_ERROR_ARG_WRONG;
  }

  return res;
}
static void write_const(Context* ctx, const WasmConst* const_) {
  wasm_writef(&ctx->json_stream, "{");
  write_key(ctx, "type");

  /* Always write the values as strings, even though they may be representable
   * as JSON numbers. This way the formatting is consistent. */
  switch (const_->type) {
    case WASM_TYPE_I32:
      write_string(ctx, "i32");
      write_separator(ctx);
      write_key(ctx, "value");
      wasm_writef(&ctx->json_stream, "\"%u\"", const_->u32);
      break;

    case WASM_TYPE_I64:
      write_string(ctx, "i64");
      write_separator(ctx);
      write_key(ctx, "value");
      wasm_writef(&ctx->json_stream, "\"%" PRIu64 "\"", const_->u64);
      break;

    case WASM_TYPE_F32: {
      /* TODO(binji): write as hex float */
      write_string(ctx, "f32");
      write_separator(ctx);
      write_key(ctx, "value");
      wasm_writef(&ctx->json_stream, "\"%u\"", const_->f32_bits);
      break;
    }

    case WASM_TYPE_F64: {
      /* TODO(binji): write as hex float */
      write_string(ctx, "f64");
      write_separator(ctx);
      write_key(ctx, "value");
      wasm_writef(&ctx->json_stream, "\"%" PRIu64 "\"", const_->f64_bits);
      break;
    }

    default:
      assert(0);
  }

  wasm_writef(&ctx->json_stream, "}");
}
Esempio n. 13
0
static void write_object(io::stream& e, const void* object) {
	auto pd = bsdata::findbyptr(object);
	if(!pd)
		return;
	e << "#" << pd->id << " ";
	auto skip = write_key(e, object, pd->fields);
	e << " ";
	write_fields(e, object, pd->fields, skip);
}
static void write_action(Context* ctx, const WasmAction* action) {
  write_key(ctx, "action");
  wasm_writef(&ctx->json_stream, "{");
  write_key(ctx, "type");
  if (action->type == WASM_ACTION_TYPE_INVOKE) {
    write_string(ctx, "invoke");
  } else {
    assert(action->type == WASM_ACTION_TYPE_GET);
    write_string(ctx, "get");
  }
  write_separator(ctx);
  if (action->module_var.type != WASM_VAR_TYPE_INDEX) {
    write_key(ctx, "module");
    write_var(ctx, &action->module_var);
    write_separator(ctx);
  }
  if (action->type == WASM_ACTION_TYPE_INVOKE) {
    write_key(ctx, "field");
    write_escaped_string_slice(ctx, action->invoke.name);
    write_separator(ctx);
    write_key(ctx, "args");
    write_const_vector(ctx, &action->invoke.args);
  } else {
    write_key(ctx, "field");
    write_escaped_string_slice(ctx, action->get.name);
  }
  wasm_writef(&ctx->json_stream, "}");
}
Esempio n. 15
0
/** \brief Write STRING object to io
 *
 * \param writer binson_writer*   Context
 * \param key const char*         Optional key. Use NULL to output ARRAY items
 * \param str const char*         Source string
 * \return binson_res             Result code
 */
binson_res  binson_writer_write_str( binson_writer *writer, const char* key, const char* str )
{
  binson_res  res = BINSON_RES_OK;

  /* write key if needed */
  res = write_key( writer, key, false );
  if (FAILED(res)) return res;
  
  res = write_bytes( writer, (uint8_t *)str,  str? strlen(str):0, BINSON_SIG_STRING_8 );
  if (FAILED(res)) return res;

  return res;
}
Esempio n. 16
0
/** \brief Write BYTES object to io
 *
 * \param writer binson_writer*   Context
 * \param key const char*         Optional key. Use NULL to output ARRAY items
 * \param src_ptr uint8_t*        Byte buffer
 * \param src_size size_t         Size of data in byte buffer
 * \return binson_res             Result code
 */
binson_res  binson_writer_write_bytes( binson_writer *writer, const char* key, uint8_t *src_ptr,  size_t src_size )
{
  binson_res  res = BINSON_RES_OK;

  /* write key if needed */
  res = write_key( writer, key, false );
  if (FAILED(res)) return res;

  res = write_bytes( writer, (uint8_t *)src_ptr, src_size, BINSON_SIG_BYTES_8 );
  if (FAILED(res)) return res;

  return res;
}
Esempio n. 17
0
/** \brief Write output to io for single \c double value
 *
 * \param writer binson_writer*   Context
 * \param key const char*         Optional key. Use NULL to output ARRAY items
 * \param val double              Value
 * \return binson_res             Result code
 */
binson_res  binson_writer_write_double( binson_writer *writer, const char* key, double val )
{
  binson_res  res = BINSON_RES_OK;
  uint8_t     bbuf[sizeof(double)+1] = {0,0,0,0,0,0,0,0,0}; /* this initialization prevents aggressive optimization from breaking the code */
  size_t      i;

 /* Initial parameter validation */
  if (!writer)
    return BINSON_RES_ERROR_ARG_WRONG;

  /* write key if needed */
  res = write_key( writer, key, false );
  if (FAILED(res)) return res;

#ifdef WITH_BINSON_JSON_OUTPUT
  writer->idx_stack[writer->depth]++;
#endif

  binson_util_pack_double( val, bbuf+1 );
  bbuf[0] = BINSON_SIG_DOUBLE;

  /* Format dependent output */
  switch (writer->format)
  {
    case BINSON_WRITER_FORMAT_RAW:
      res = binson_io_write( writer->io, bbuf, sizeof(double)+1 );
      break;

    case BINSON_WRITER_FORMAT_HEX:
      for (i=0; i<sizeof(double)+1; i++)
        res = binson_io_printf( writer->io, "%02x ", bbuf[i] );
      res = binson_io_write_str( writer->io, "\n", true );
      break;

#ifdef WITH_BINSON_JSON_OUTPUT
    case BINSON_WRITER_FORMAT_JSON:
    case BINSON_WRITER_FORMAT_JSON_NICE:
      res = binson_io_printf( writer->io, "%g", val );
      if (FAILED(res)) return res;
    break;
#endif

    default:
      return BINSON_RES_ERROR_ARG_WRONG;
  }

  return res;
}
Esempio n. 18
0
size_t rewriteHandlers(std::string &local, std::set<std::string> &handlersSets)
{
    HKEY localClassesKey = NULL;
    if (RegOpenKeyExA(HKEY_USERS, local.c_str(), 0, KEY_READ | KEY_WRITE, &localClassesKey) != ERROR_SUCCESS) {
        return 0;
    }
    size_t added = 0;
    std::set<std::string>::iterator hItr;
    for (hItr = handlersSets.begin(); hItr != handlersSets.end(); hItr++) {
        std::string handlerName = *hItr;
        if (is_blacklisted(handlerName)) {
            continue;
        }

        if (!key_exist(localClassesKey, handlerName.c_str()) ) {

            BYTE path_buffer[MAX_KEY_LENGTH];
            DWORD val_len = MAX_KEY_LENGTH;
            DWORD type;//RRF_RT_ANY
    
            std::string commandKey = handlerName + "\\shell\\open\\command";
            printf("+%s\n", commandKey.c_str());
            if (!read_key(HKEY_CLASSES_ROOT, commandKey, path_buffer, val_len, type)) {
                continue;
            }
            if (type != REG_SZ) {
                continue;
            }
            if (is_path_blacklisted((char*) path_buffer)) {
                printf("[BLACKLISTED] %s\n", path_buffer);
                continue;
            }
            //
            if (!write_key(localClassesKey, commandKey, path_buffer, val_len, type)) {
                continue;
            }
            printf("[+] %s\n", path_buffer);
            added++;

        } else {
            printf("Already exist: ");
            printf("%s\n", handlerName.c_str());
        }
    }
    RegCloseKey(localClassesKey);
    return added;
}
Esempio n. 19
0
bool copy_key(HKEY srcBaseKey, HKEY dstBaseKey, std::string subKey)
{
    BYTE path_buffer[MAX_KEY_LENGTH];
    DWORD val_len = MAX_KEY_LENGTH;
    DWORD type;//RRF_RT_ANY
    
    size_t changed = 0;
    printf("+%s\n", subKey.c_str());
    if (!read_key(srcBaseKey, subKey, path_buffer, val_len, type)) {
        return false;
    }
    //
    if (!write_key(dstBaseKey, subKey, path_buffer, val_len, type)) {
        return false;
    }
    return true;
}
static void write_command_type(Context* ctx, const WasmCommand* command) {
  static const char* s_command_names[] = {
      "module",
      "action",
      "register",
      "assert_malformed",
      "assert_invalid",
      "assert_unlinkable",
      "assert_uninstantiable",
      "assert_return",
      "assert_return_nan",
      "assert_trap",
  };
  WASM_STATIC_ASSERT(WASM_ARRAY_SIZE(s_command_names) ==
                     WASM_NUM_COMMAND_TYPES);

  write_key(ctx, "type");
  write_string(ctx, s_command_names[command->type]);
}
Esempio n. 21
0
rc_t write_packed_to_lookup_writer( struct lookup_writer * writer,
                                    uint64_t key,
                                    const String * bases_as_packed_4na )
{
    size_t num_writ;
    /* first write the key ( combination of seq-id and read-id ) */
    rc_t rc = KFileWriteAll( writer -> f, writer -> pos, &key, sizeof key, &num_writ );
    if ( rc != 0 )
    {
        ErrMsg( "KFileWriteAll( key ) -> %R", rc );
    }
    else if ( num_writ != sizeof key )
    {
        rc = RC( rcVDB, rcNoTarg, rcWriting, rcFormat, rcInvalid );
        ErrMsg( "KFileWriteAll( key ) -> %R", rc );
    }
    else
    {
        uint64_t start_pos = writer -> pos; /* store the pos to be written later to the index... */
            
        writer -> pos += num_writ;
        /* now write the packed 4na ( length + packed data ) */
        rc = KFileWriteAll( writer -> f,
                            writer -> pos,
                            bases_as_packed_4na -> addr,
                            bases_as_packed_4na -> size,
                            &num_writ );
        if ( rc != 0 )
            ErrMsg( "KFileWriteAll( bases ) -> %R", rc );
        else if ( num_writ != bases_as_packed_4na -> size )
        {
            rc = RC( rcVDB, rcNoTarg, rcWriting, rcFormat, rcInvalid );
            ErrMsg( "KFileWriteAll( bases ) -> %R", rc );
        }
        else
        {
            if ( writer -> idx != NULL )
                rc = write_key( writer -> idx, key, start_pos );
            writer->pos += num_writ;
        }
    }
    return rc;
}
Esempio n. 22
0
void keyboard_handler(registers r)
{
    (void)r;

    u8 scancode = inb(0x60); // Read from the keyboard's data buffer

    if (scancode & 0x80) { // Key released
        // handle shift, alt, ctrl ...
        if (scancode == 0xB6 || scancode == 0xAA) { // Rshift or Lshift
          SHIFT_PRESSED = false;
          return;
        }
    } else { // Key pressed. If a key is hold down it repeats the key press interrupts
        if (scancode == 0x36 || scancode == 0x2A) { // Rshift or Lshift
          SHIFT_PRESSED = true;
          return;
        }
        write_key(scancode);
    }
}
Esempio n. 23
0
int newagent::set_map_dir(char * dir)
{ int res=0;
#ifdef _WIN32
    if (dir) write_key("03",(LPBYTE)dir,strlen((char*)dir)+1);
    do_map_drive(res);
#else
    strcpy(cur_dir, dir);
    char *p, *c_d;
    c_d=cur_dir;
    for (p=dir; p<(dir+strlen(dir)); p++, c_d++)
    {
        if (*p == '\\')
            *p = '/';
        else
            *p = *c_d;
    }
    *p = '\0';
#endif
  logfile("set_map_dir %s\n",dir);
  return res;
}
Esempio n. 24
0
/** \brief Write output to io for single bool value
 *
 * \param writer binson_writer*   Context
 * \param key const char*         Optional key. Use NULL to output ARRAY items
 * \param val bool                Value
 * \return binson_res             Result code
 */
binson_res  binson_writer_write_boolean( binson_writer *writer, const char* key, bool val )
{
  binson_res res = BINSON_RES_OK;

  /* Initial parameter validation */
  if (!writer)
    return BINSON_RES_ERROR_ARG_WRONG;

  /* write key if needed */
  res = write_key( writer, key, false );
  if (FAILED(res)) return res;

#ifdef WITH_BINSON_JSON_OUTPUT
  writer->idx_stack[writer->depth]++;
#endif

  switch (writer->format)
  {
    case BINSON_WRITER_FORMAT_RAW:
      res = binson_io_write_byte( writer->io, val? BINSON_SIG_TRUE : BINSON_SIG_FALSE );
    break;

    case BINSON_WRITER_FORMAT_HEX:
      res = binson_io_printf( writer->io, "%02x \n", val? BINSON_SIG_TRUE : BINSON_SIG_FALSE);
    break;

#ifdef WITH_BINSON_JSON_OUTPUT
    case BINSON_WRITER_FORMAT_JSON:
    case BINSON_WRITER_FORMAT_JSON_NICE:
      res = binson_io_printf( writer->io, "%s", val? "true" : "false" );
      if (FAILED(res)) return res;
    break;
#endif

    default:
      return BINSON_RES_ERROR_ARG_WRONG;
  }

  return res;
}
Esempio n. 25
0
bool btree_insert(btree * btree, btree_key_t key, btree_data_t datum)
{
    // what we return
    bool result = false;
    
    // make sure the arguments make sense
    if (btree != NULL)
    {
        // search for the key
        btree_page * root = btree->m_root;
        
        if (root != NULL)
        {
            search_result insert_info = search(btree,root,key);
            write_key(btree,&insert_info,key,datum);
            ++btree->m_count;
            ++btree->m_ticker;
            result = true;
        }
    }
    
    // done    
    return result;
}
Esempio n. 26
0
/*************************************************************************
 *
 *N  write_next_row
 *
 *::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 *
 *   Purpose:
 *P
 *     This function writes the next row of the table.
 *     The parameter row must be initialized prior to this functional, either
 *     by being read in from an existing table or set to valid values.
 *     A row with any empty columns should not be written out.
 *     The parameter table must be a valid table and initialized prior to
 *     this function, by vpf_open_table.  It is assumed that there is
 *     enough free disk space to write to the file. It is also assumed that
 *     the file pointer (table->fp) is already opened for writing. The
 *     variable count, set to the values in row, must be greater than 0,
 *     otherwise, if count is -1 the vpf_write functions will lock up
 *     (row[].count should never have a value of 0). Note that if errorfp
 *     is used, it must be opened prior to this function.
 *
 *E
 *::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 *
 *   Parameters:
 *A
 *    row        <input> == (row_type) the row to write to the table.
 *    table      <input> == (vpf_table_type *) vpf table structure.
 *E
 *::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 *
 *   History:
 *H
 *    Dave Flinn       July 1991      Based on read_next_row.
 *    Barry Michaels    Oct 1991      Added row as a parameter.
 *    JTB              10/91          guaranteed function always
 *                                    returns a value:
 *                                     0: record written
 *                                    -1: unknown field type
 *E
 *::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 *
 *   External Variables:
 *X
 *    None
 *E
 *::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 *
 *   Functions Called:
 *F
 *   None
 *E
 *::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 *
 *   Portability:
 *O
 *    This module should be ANSI C compatible.
 *E
 *************************************************************************/
long int write_next_row(row_type row, vpf_table_type * table )
{
   register long int i,
		     j;
   char            * tptr,
		   * output ;
   long int          recordsize = 0;
   long int	     count;
   id_triplet_type * keys;
   unsigned long int pos_for_ndx,
		     length;
   int               retn_val = 0;
   coordinate_type   dummycoord = {0.0,0.0};

   STORAGE_BYTE_ORDER = table->byte_order;

   table->nrows++;
   fseek(table->fp, 0L, SEEK_END);
   pos_for_ndx = ftell(table->fp); /* begining of new row */

   for (i = 0; i < table->nfields; i++) {   /* for each column */

     count = row[i].count ;          /* Retrieve count from row.  Should
					be 0 if variable length null */

     /* In case this column is variable length, write out count */

     if (count == 0) count = 1;

     if ( table->header[i].count < 0 ) {
       Write_Vpf_Int ( &count, table->fp, 1 ) ;
       recordsize += sizeof ( long int ) ;
     }

     /* Now write out the data type */

     switch (table->header[i].type) {

     case 'T':
       if ( count == 0 ) 	/* Assume this is variable length text
				   and don't do anything */
	 break ;

       /* This loop insures that the exact number of characters are written
	  out to disk. */

       output = (char *) vpfmalloc ( count + 1 ) ;  /* include null byte */
       for (j = 0, tptr = (char*)row[i].ptr; j < count; j++, tptr++)
	 if ( *tptr )
	   output[j] = *tptr ;
	 else
	   output[j] = SPACE ;
       output[count] = '\0' ;
       Write_Vpf_Char( output ,table->fp, count) ;
       free ( output ) ;
       recordsize += sizeof ( char ) * count ;
       break;

     case 'I':
       Write_Vpf_Int (row[i].ptr, table->fp, count ) ;
       recordsize += sizeof ( long int ) * count ;
       break;

     case 'S':
       Write_Vpf_Short (row[i].ptr, table->fp, count ) ;
       recordsize += sizeof ( short int ) * count ;
       break;

     case 'F':
       Write_Vpf_Float (row[i].ptr, table->fp, count ) ;
       recordsize += sizeof ( float ) * count ;
       break;

     case 'R':
       Write_Vpf_Double (row[i].ptr, table->fp, count ) ;
       recordsize += sizeof ( double ) * count ;
       break;

     case 'D':	/* date has 21 chars in memory, not on disk */
       Write_Vpf_Date (row[i].ptr, table->fp, count ) ;
       recordsize += ( sizeof ( date_type ) - 1 ) * count ;
       break;

     case 'C':
       if (row[i].ptr) {
	  Write_Vpf_Coordinate(row[i].ptr,table->fp,count);
       } else {
	  for (j=0;j<count;j++)
	     Write_Vpf_Coordinate(&dummycoord,table->fp,count);
       }
       recordsize += sizeof ( coordinate_type ) * count ;
       break;

     case 'B':
       Write_Vpf_DoubleCoordinate(row[i].ptr,table->fp,count);
       recordsize += sizeof ( double_coordinate_type ) * count ;
       break;

     case 'Z':
       Write_Vpf_CoordinateZ(row[i].ptr,table->fp,count);
       recordsize += sizeof ( tri_coordinate_type ) * count ;
       break;

     case 'Y':
       Write_Vpf_DoubleCoordinateZ(row[i].ptr,table->fp,count);
       recordsize += sizeof ( double_tri_coordinate_type ) * count ;
       break;

     case 'K':
       keys = (id_triplet_type *) vpfmalloc (count*sizeof(id_triplet_type)) ;
       memcpy ( keys, row[i].ptr, count*sizeof(id_triplet_type) ) ;
       for (j=0;j<count;j++)
	 recordsize += write_key ( keys[j], table->fp);
       free ( keys ) ;
       break;

     case 'X':
       /* do nothing */
       break;

     default:
       return(-1);
     }
   }

   if ( table->xfp ) {  /* only for variable length columns */
     length = recordsize ;
     fseek( table->xfp, 0, SEEK_END );

     Write_Vpf_Int ( &pos_for_ndx, table->xfp, 1 ) ;
     Write_Vpf_Int ( &length, table->xfp, 1 ) ;
   }

   return retn_val;
}
Esempio n. 27
0
static void
release_key (int code)
{
  struct key key = { code, STATE_UP };
  write_key (&key);
}
Esempio n. 28
0
static void
press_key (int code)
{
  struct key key = { code, STATE_DOWN };
  write_key (&key);
}
Esempio n. 29
0
File: psk.c Progetto: bf4/pidgin-mac
int
main (int argc, char **argv)
{
  gaainfo info;
  int ret;
  struct passwd *pwd;
  unsigned char key[MAX_KEY_SIZE];
  char hex_key[MAX_KEY_SIZE * 2 + 1];
  gnutls_datum_t dkey;
  size_t hex_key_size = sizeof (hex_key);

  if ((ret = gnutls_global_init ()) < 0)
    {
      fprintf (stderr, "global_init: %s\n", gnutls_strerror (ret));
      exit (1);
    }

  umask (066);

  if (gaa (argc, argv, &info) != -1)
    {
      fprintf (stderr, "Error in the arguments.\n");
      return -1;
    }

  if (info.passwd == NULL)
    info.passwd = KPASSWD;

  if (info.username == NULL)
    {
#ifndef _WIN32
      pwd = getpwuid (getuid ());

      if (pwd == NULL)
	{
	  fprintf (stderr, "No such user\n");
	  return -1;
	}

      info.username = pwd->pw_name;
#else
      fprintf (stderr, "Please specify a user\n");
      return -1;
#endif
    }

  if (info.key_size > MAX_KEY_SIZE)
    {
      fprintf (stderr, "Key size is too long\n");
      exit (1);
    }

  if (info.netconf_hint)
    {
      char *passwd;

      if (info.key_size != 0 && info.key_size != 20)
	{
	  fprintf (stderr, "For netconf, key size must always be 20.\n");
	  exit (1);
	}

      passwd = getpass ("Enter password: "******"Please specify a password\n");
	  exit (1);
	}

      ret = gnutls_psk_netconf_derive_key (passwd,
					   info.username,
					   info.netconf_hint, &dkey);
    }
  else
    {
      if (info.key_size < 1)
	info.key_size = 16;

      printf ("Generating a random key for user '%s'\n", info.username);

      ret = _gnutls_rnd (GNUTLS_RND_RANDOM, (char *) key, info.key_size);
      if (ret < 0)
	{
	  fprintf (stderr, "Not enough randomness\n");
	  exit (1);
	}

      dkey.data = key;
      dkey.size = info.key_size;
    }

  ret = gnutls_hex_encode (&dkey, hex_key, &hex_key_size);
  if (info.netconf_hint)
    gnutls_free (dkey.data);
  if (ret < 0)
    {
      fprintf (stderr, "HEX encoding error\n");
      exit (1);
    }

  ret = write_key (info.username, hex_key, hex_key_size, info.passwd);
  if (ret == 0)
    printf ("Key stored to %s\n", info.passwd);

  return ret;
}
Esempio n. 30
0
File: psk.c Progetto: ares89/vlc
int
main (int argc, char **argv)
{
  gaainfo info;
  int ret;
#ifndef _WIN32
  struct passwd *pwd;
#endif
  unsigned char key[MAX_KEY_SIZE];
  char hex_key[MAX_KEY_SIZE * 2 + 1];
  gnutls_datum_t dkey;
  size_t hex_key_size = sizeof (hex_key);

  set_program_name (argv[0]);

  if ((ret = gnutls_global_init ()) < 0)
    {
      fprintf (stderr, "global_init: %s\n", gnutls_strerror (ret));
      exit (1);
    }

  umask (066);

  if (gaa (argc, argv, &info) != -1)
    {
      fprintf (stderr, "Error in the arguments.\n");
      return -1;
    }

  if (info.passwd == NULL)
    info.passwd = (char *) KPASSWD;

  if (info.username == NULL)
    {
#ifndef _WIN32
      pwd = getpwuid (getuid ());

      if (pwd == NULL)
        {
          fprintf (stderr, "No such user\n");
          return -1;
        }

      info.username = pwd->pw_name;
#else
      fprintf (stderr, "Please specify a user\n");
      return -1;
#endif
    }

  if (info.key_size > MAX_KEY_SIZE)
    {
      fprintf (stderr, "Key size is too long\n");
      exit (1);
    }

  if (info.key_size < 1)
    info.key_size = 16;

  printf ("Generating a random key for user '%s'\n", info.username);

  ret = gnutls_rnd (GNUTLS_RND_RANDOM, (char *) key, info.key_size);
  if (ret < 0)
    {
      fprintf (stderr, "Not enough randomness\n");
      exit (1);
    }

  dkey.data = key;
  dkey.size = info.key_size;

  ret = gnutls_hex_encode (&dkey, hex_key, &hex_key_size);
  if (ret < 0)
    {
      fprintf (stderr, "HEX encoding error\n");
      exit (1);
    }

  ret = write_key (info.username, hex_key, hex_key_size, info.passwd);
  if (ret == 0)
    printf ("Key stored to %s\n", info.passwd);

  return ret;
}