Пример #1
0
/*=========================================================================*\
      Get boolean value from repository 
         return false on error of if key is not found
\*=========================================================================*/
bool persistGetBool( const char *key )
{
  json_t *jObj;

  DBGMSG( "persistGetBool: (%s)", key ); 
    
/*------------------------------------------------------------------------*\
    Get Object
\*------------------------------------------------------------------------*/
  jObj = persistGetJSON( key );
  if( !jObj ) {
  	DBGMSG( "persistGetBool: (%s) not set", key );
    return false;  
  }
  
/*------------------------------------------------------------------------*\
    Check type
\*------------------------------------------------------------------------*/
  if( !json_is_true(jObj) && !json_is_false(jObj) ) {
     logwarn( "Value for key \"%s\" is not a boolean (%d): ", 
                          key, json_typeof(jObj) );
     return false;
  }  

/*------------------------------------------------------------------------*\
    return real value 
\*------------------------------------------------------------------------*/
  bool value = json_is_true( jObj );
  DBGMSG( "persistGetBool: (%s)=%s", key, value?"True":"False" ); 
  return value;
}
Пример #2
0
ServerRepo ServerRepo::fromJSON(const json_t *json, json_error_t */* error */)
{
    ServerRepo repo;
    repo.id = getStringFromJson(json, "id");
    repo.name = getStringFromJson(json, "name");
    repo.description = getStringFromJson(json, "desc");

    repo.mtime = json_integer_value(json_object_get(json, "mtime"));
    repo.size = json_integer_value(json_object_get(json, "size"));
    repo.root = getStringFromJson(json, "root");

    repo.encrypted = json_is_true(json_object_get(json, "encrypted"));

    repo.type = getStringFromJson(json, "type");
    repo.permission = getStringFromJson(json, "permission");
    repo.readonly = (repo.permission == "r") ? true : false;

    repo._virtual = json_is_true(json_object_get(json, "virtual"));

    if (repo.type == "grepo") {
        repo.owner = getStringFromJson(json, "share_from");
        repo.group_name = getStringFromJson(json, "owner");
        repo.group_id = json_integer_value(json_object_get(json, "groupid"));
    } else {
        repo.owner = getStringFromJson(json, "owner");
        repo.group_name = QString();
        repo.group_id = 0;
    }

    return repo;
}
Пример #3
0
static void submit_work(CURL *curl, struct work *work)
{
	char *hexstr = NULL;
	json_t *val, *res;
	char s[345], timestr[64];
	time_t now;
	struct tm *tm;

	now = time(NULL);

	/* build hex string */
	hexstr = bin2hex(work->data, sizeof(work->data));
	if (!hexstr) {
		fprintf(stderr, "submit_work OOM\n");
		goto out;
	}

	/* build JSON-RPC request */
	sprintf(s,
	      "{\"method\": \"getwork\", \"params\": [ \"%s\" ], \"id\":1}\r\n",
		hexstr);

	if (opt_debug)
		fprintf(stderr, "DBG: sending RPC call:\n%s", s);

	/* issue JSON-RPC request */
	val = json_rpc_call(curl, rpc_url, userpass, s);
	if (!val) {
		fprintf(stderr, "submit_work json_rpc_call failed\n");
		goto out;
	}

	res = json_object_get(val, "result");

	tm = localtime(&now);
	strftime(timestr, sizeof(timestr), "%Y-%m-%d %H:%M:%S", tm);

	printf("%s: PROOF OF WORK RESULT: %s\n",
	       timestr, json_is_true(res) ? "true (yay!!!)" : "false (booooo)");

	if (opt_log) {
		FILE *f = fopen(opt_log,"a");
		fprintf(f, "%s: PROOF OF WORK RESULT: %s\n",
		        timestr, json_is_true(res) ? "true (yay!!!)" : "false (booooo)");
		fprintf(f, "%s: DATA: %s\n", timestr, hexstr);
		fclose(f);
	}

	json_decref(val);

out:
	free(hexstr);
}
Пример #4
0
Status
loginServerOtpPending(std::list<DataChunk> users, std::list<bool> &isPending)
{
    const auto url = ABC_SERVER_ROOT "/v1/otp/pending/check";

    std::string param;
    std::map<std::string, bool> userMap;
    std::list<std::string> usersEncoded;
    for (const auto &u : users)
    {
        std::string username = base64Encode(u);
        param += (username + ",");
        userMap[username] = false;
        usersEncoded.push_back(username);
    }
    JsonObject json;
    ABC_CHECK(json.set("l1s", param));

    HttpReply reply;
    ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));
    ServerReplyJson replyJson;
    ABC_CHECK(replyJson.decode(reply));

    JsonArray arrayJson = replyJson.results();
    size_t size = arrayJson.size();
    for (size_t i = 0; i < size; i++)
    {
        json_t *pJSON_Row = arrayJson[i].get();
        if (!pJSON_Row || !json_is_object(pJSON_Row))
            return ABC_ERROR(ABC_CC_JSONError, "Error parsing JSON array element object");

        json_t *pJSON_Value = json_object_get(pJSON_Row, "login");
        if (!pJSON_Value || !json_is_string(pJSON_Value))
            return ABC_ERROR(ABC_CC_JSONError, "Error otp/pending/login JSON");
        std::string username(json_string_value(pJSON_Value));

        pJSON_Value = json_object_get(pJSON_Row, ABC_SERVER_JSON_OTP_PENDING);
        if (!pJSON_Value || !json_is_boolean(pJSON_Value))
            return ABC_ERROR(ABC_CC_JSONError, "Error otp/pending/pending JSON");
        if (json_is_true(pJSON_Value))
        {
            userMap[username] = json_is_true(pJSON_Value);
        }
    }
    isPending.clear();
    for (auto &username: usersEncoded)
    {
        isPending.push_back(userMap[username]);
    }

    return Status();
}
Пример #5
0
json_t* OBSAPIMessageHandler::HandleSetVolume(OBSAPIMessageHandler* handler, json_t* message)
{
    json_t* channel = json_object_get(message, "channel");
    json_t* volume = json_object_get(message, "volume");
    json_t* finalValue = json_object_get(message, "final");

    if(volume == NULL)
    {
        return GetErrorResponse("Volume not specified.");
    }

    if(!json_is_number(volume))
    {
        return GetErrorResponse("Volume not number.");
    }
    
    float val = (float) json_number_value(volume);
    val = min(1.0f, max(0.0f, val));

    if(finalValue == NULL)
    {
        return GetErrorResponse("Final not specified.");
    }
    
    if(!json_is_boolean(finalValue))
    {
        return GetErrorResponse("Final is not a boolean.");
    }

    if(channel != NULL && json_typeof(channel) == JSON_STRING)
    {
        const char* channelVal = json_string_value(channel);
        if(stricmp(channelVal, "desktop") == 0)
        {
            OBSSetDesktopVolume(val, json_is_true(finalValue));
        }
        else if(stricmp(channelVal, "microphone") == 0)
        {
            OBSSetMicVolume(val, json_is_true(finalValue));
        }
        else
        {
            return GetErrorResponse("Invalid channel specified.");
        }
    }
    else
    {
        return GetErrorResponse("Channel not specified.");
    }
    return GetOkResponse();
}
Пример #6
0
UITheme * UITheme::FromJson(const json_t * json)
{
    const char * themeName = json_string_value(json_object_get(json, "name"));
    if (themeName == nullptr)
    {
        ThrowThemeLoadException();
    }

    json_t * jsonEntries = json_object_get(json, "entries");
    size_t numEntries = json_object_size(jsonEntries);

    UITheme * result = nullptr;
    try
    {
        result = new UITheme(themeName);

        if (json_is_true(json_object_get(json, "useLightsRide")))
        {
            result->Flags |= UITHEME_FLAG_USE_LIGHTS_RIDE;
        }
        if (json_is_true(json_object_get(json, "useLightsPark")))
        {
            result->Flags |= UITHEME_FLAG_USE_LIGHTS_PARK;
        }
        if (json_is_true(json_object_get(json, "useAltScenarioSelectFont")))
        {
            result->Flags |= UITHEME_FLAG_USE_ALTERNATIVE_SCENARIO_SELECT_FONT;
        }

        const char * jkey;
        json_t     * jvalue;
        size_t       i = 0;
        json_object_foreach(jsonEntries, jkey, jvalue)
        {
            const WindowThemeDesc * wtDesc = GetWindowThemeDescriptor(jkey);
            if (wtDesc == nullptr) continue;

            UIThemeWindowEntry entry = UIThemeWindowEntry::FromJson(wtDesc, jvalue);
            result->SetEntry(&entry);
        }

        return result;
    }
    catch (Exception ex)
    {
        delete result;
        throw ex;
    }
}
Пример #7
0
json_t *json_deep_copy(json_t *json)
{
    if(!json)
        return NULL;

    if(json_is_object(json))
        return json_object_deep_copy(json);

    if(json_is_array(json))
        return json_array_deep_copy(json);

    /* for the rest of the types, deep copying doesn't differ from
       shallow copying */

    if(json_is_string(json))
        return json_string_copy(json);

    if(json_is_integer(json))
        return json_integer_copy(json);

    if(json_is_real(json))
        return json_real_copy(json);

    if(json_is_true(json) || json_is_false(json) || json_is_null(json))
        return json;

    return NULL;
}
Пример #8
0
static
QList<QVariant> listFromJSON(json_t *array)
{
    QList<QVariant> ret;
    size_t array_size = json_array_size(array);
    json_t *value;

    for(size_t index = 0; index < array_size &&
        (value = json_array_get(array, index)); ++index) {
        /* block of code that uses index and value */
        QVariant v;
        if (json_is_object(value)) {
            v = mapFromJSON(value, NULL);
        } else if (json_is_array(value)) {
            v = listFromJSON(value);
        } else if (json_is_string(value)) {
            v = QString::fromUtf8(json_string_value(value));
        } else if (json_is_integer(value)) {
            v = json_integer_value(value);
        } else if (json_is_real(value)) {
            v = json_real_value(value);
        } else if (json_is_boolean(value)) {
            v = json_is_true(value);
        }
        if (v.isValid()) {
          ret.push_back(v);
        }
    }
    return ret;
}
Пример #9
0
static void draw_likes() {
	int likes = 0, liked = 0, liked_padding = 0;
	char *liked_str = NULL;
	json_t *photo, *likes_node, *liked_node, *count_node;

	photo = photos[photo_pos];

	likes_node = json_object_get(photo, "likes");
	count_node = json_object_get(likes_node, "count");
	likes = json_integer_value(count_node);

	liked_padding = 7;
	liked_node = json_object_get(photo, "user_has_liked");
	liked = json_is_true(liked_node);
	liked_str = malloc(sizeof(char) * 11);

	if (liked) {
		liked_padding -= 4;
		sprintf(liked_str, "\x1B[31m♥\x1B[0m %d", likes);
	} else {
		sprintf(liked_str, "♥ %d", likes);
	}

	printf("\033[%d;%dH%10s", 23, left + container - liked_padding, liked_str);

	if (liked_str) {
		free(liked_str);
	}
}
Пример #10
0
json_t *json_copy(json_t *json)
{
    if(!json)
        return NULL;

    if(json_is_object(json))
        return json_object_copy(json);

    if(json_is_array(json))
        return json_array_copy(json);

    if(json_is_string(json))
        return json_string_copy(json);

    if(json_is_integer(json))
        return json_integer_copy(json);

    if(json_is_real(json))
        return json_real_copy(json);

    if(json_is_true(json) || json_is_false(json) || json_is_null(json))
        return json;

    return NULL;
}
Пример #11
0
cxBool cxJsonPushValue(json_t *value)
{
    if(json_is_integer(value)){
        lua_pushinteger(gL,(int)json_integer_value(value));
    }else if(json_is_string(value)){
        lua_pushstring(gL, json_string_value(value));
    }else if(json_is_number(value)){
        lua_pushnumber(gL, json_number_value(value));
    }else if(json_is_true(value)){
        lua_pushboolean(gL, 1);
    }else if(json_is_false(value)){
        lua_pushboolean(gL, 0);
    }else if(json_is_null(value)){
        lua_pushnil(gL);
    }else if(json_is_real(value)){
        lua_pushnumber(gL, json_real_value(value));
    }else if(json_is_object(value)){
        cxJsonPushObject(value);
    }else if(json_is_array(value)){
        cxJsonPushArray(value);
    }else{
        return false;
    }
    return true;
}
Пример #12
0
void
debug_show_value(GhbValue *gval)
{
    GhbType tp;

    tp = ghb_value_type(gval);
    if (tp == GHB_STRING)
    {
        g_message("Type %s value %s", "string", json_string_value(gval));
    }
    else if (tp == GHB_INT)
    {
        g_message("Type %s value %"JSON_INTEGER_FORMAT, "int",
                  json_integer_value(gval));
    }
    else if (tp == GHB_DOUBLE)
    {
        g_message("Type %s value %f", "double", json_real_value(gval));
    }
    else if (tp == GHB_BOOL)
    {
        g_message("Type %s value %d", "boolean", json_is_true(gval));
    }
    else if (tp == GHB_ARRAY)
    {
        g_message("Type %s", "array");
    }
    else if (tp == GHB_DICT)
    {
        g_message("Type %s", "dict");
    }
}
Пример #13
0
/* 判断janson的类型 */
int my_json_type(json_t *value)
{
    if(json_is_object(value))
	{
        printf("json_is_object\n");
		return JSON_OBJECT;
	}

    if(json_is_array(value))
	{
        printf("json_is_array\n");
		return JSON_ARRAY;
	}

    if(json_is_string(value))
	{
        printf("json_is_string\n");
		return JSON_STRING;
	}

    if(json_is_integer(value))
	{
        printf("json_is_integer\n");
		return JSON_INTEGER;
	}

    if(json_is_real(value))
	{
        printf("json_is_real\n");
		return JSON_REAL;
	}

    if(json_is_number(value))
	{
        printf("json_is_number\n");
	}

    if(json_is_boolean(value))
	{
        printf("json_is_boolean\n");
	}

    if(json_is_null(value))
	{
        printf("json_is_null\n");
		return JSON_NULL;
	}

	if(json_is_true(value))
	{
        printf("json_boolean(1)\n");
		return JSON_TRUE;
	}

    if(json_is_false(value))
	{
        printf("json_boolean(0)\n");
		return JSON_FALSE;
	}
}
Пример #14
0
tABC_CC ABC_LoginServerOtpStatus(const Lobby &lobby, tABC_U08Buf LP1,
    bool *on, long *timeout, tABC_Error *pError)
{
    tABC_CC cc = ABC_CC_Ok;

    json_t *pJSON_Value = NULL;
    JsonPtr reply;

    std::string url = ABC_SERVER_ROOT "/otp/status";

    ABC_CHECK_RET(ABC_LoginServerOtpRequest(url.c_str(), lobby, LP1, &reply, pError));

    pJSON_Value = json_object_get(reply.get(), ABC_SERVER_JSON_OTP_ON);
    ABC_CHECK_ASSERT((pJSON_Value && json_is_boolean(pJSON_Value)), ABC_CC_JSONError, "Error otp/on JSON");
    *on = json_is_true(pJSON_Value);

    if (*on)
    {
        pJSON_Value = json_object_get(reply.get(), ABC_SERVER_JSON_OTP_TIMEOUT);
        ABC_CHECK_ASSERT((pJSON_Value && json_is_integer(pJSON_Value)), ABC_CC_JSONError, "Error otp/timeout JSON");
        *timeout = json_integer_value(pJSON_Value);
    }

exit:
    return cc;
}
Пример #15
0
void GetEventsRequest::requestSuccess(QNetworkReply& reply)
{
    json_error_t error;
    json_t *root = parseJSON(reply, &error);
    if (!root) {
        qDebug("GetEventsRequest: failed to parse json:%s\n", error.text);
        emit failed(ApiError::fromJsonError());
        return;
    }

    QScopedPointer<json_t, JsonPointerCustomDeleter> json(root);

    bool more = false;
    int more_offset = -1;

    json_t* array = json_object_get(json.data(), "events");
    std::vector<SeafEvent> events = SeafEvent::listFromJSON(array, &error);

    more = json_is_true(json_object_get(json.data(), "more"));
    if (more) {
        more_offset = json_integer_value(json_object_get(json.data(), "more_offset"));
    }

    emit success(events, more_offset);
}
Пример #16
0
static void decode_any()
{
    json_t *json;
    json_error_t error;

    json = json_loads("\"foo\"", JSON_DECODE_ANY, &error);
    if (!json || !json_is_string(json))
        fail("json_load decoded any failed - string");
    json_decref(json);

    json = json_loads("42", JSON_DECODE_ANY, &error);
    if (!json || !json_is_integer(json))
        fail("json_load decoded any failed - integer");
    json_decref(json);

    json = json_loads("true", JSON_DECODE_ANY, &error);
    if (!json || !json_is_true(json))
        fail("json_load decoded any failed - boolean");
    json_decref(json);

    json = json_loads("null", JSON_DECODE_ANY, &error);
    if (!json || !json_is_null(json))
        fail("json_load decoded any failed - null");
    json_decref(json);
}
Пример #17
0
static void parse_config(void)
{
	int i;
	json_t *val;

	if (!json_is_object(opt_config))
		return;

	for (i = 0; i < ARRAY_SIZE(options); i++) {
		if (!options[i].name)
			break;
		if (!strcmp(options[i].name, "config"))
			continue;

		val = json_object_get(opt_config, options[i].name);
		if (!val)
			continue;

		if (options[i].has_arg && json_is_string(val)) {
			char *s = strdup(json_string_value(val));
			if (!s)
				break;
			parse_arg(options[i].val, s);
			free(s);
		} else if (!options[i].has_arg && json_is_true(val))
			parse_arg(options[i].val, "");
		else
			fprintf(stderr, "JSON option %s invalid\n",
				options[i].name);
	}
}
Пример #18
0
static kbool_t GetJsonBoolean(KonohaContext *kctx, struct JsonBuf *jsonbuf, const char *key, size_t keylen_or_zero, kbool_t defval)
{
	json_t* obj = (key != NULL) ? json_object_get(jsonbuf->jsonobj, key) : jsonbuf->jsonobj;
	if(json_is_boolean(obj)) {
		return (kbool_t)json_is_true(obj);
	}
	return defval;
}
Пример #19
0
static bool get_bool_orelse(json_t* json, const char* key, bool def) {
    json_t* v = json_object_get(json, key);
    if (v == NULL)
	return def;
    if (json_is_null(v))
	return def;
    return json_is_true(v) ? true : false;
}
Пример #20
0
static inline bool get_bool_val(json_t *service, const char *key)
{
	json_t *bool_val = json_object_get(service, key);
	if (!bool_val || !json_is_boolean(bool_val))
		return false;

	return json_is_true(bool_val);
}
Пример #21
0
// Compute the effective value of the root_files configuration and
// return a json reference.  The caller must decref the ref when done
// (we may synthesize this value).   Sets enforcing to indicate whether
// we will only allow watches on the root_files.
// The array returned by this function (if not NULL) is guaranteed to
// list .watchmanconfig as its zeroth element.
json_t *cfg_compute_root_files(bool *enforcing) {
  json_t *ref;

  // This is completely undocumented and will go away soon. Do not document or
  // use!
  bool ignore_watchmanconfig = cfg_get_bool(NULL, "_ignore_watchmanconfig",
                                            false);

  *enforcing = false;

  ref = cfg_get_json(NULL, "enforce_root_files");
  if (ref) {
    if (!json_is_boolean(ref)) {
      w_log(W_LOG_FATAL,
          "Expected config value enforce_root_files to be boolean\n");
    }
    *enforcing = json_is_true(ref);
  }

  ref = cfg_get_json(NULL, "root_files");
  if (ref) {
    if (!is_array_of_strings(ref)) {
      w_log(W_LOG_FATAL,
          "global config root_files must be an array of strings\n");
      *enforcing = false;
      return NULL;
    }
    prepend_watchmanconfig_to_array(ref);

    json_incref(ref);
    return ref;
  }

  // Try legacy root_restrict_files configuration
  ref = cfg_get_json(NULL, "root_restrict_files");
  if (ref) {
    if (!is_array_of_strings(ref)) {
      w_log(W_LOG_FATAL, "deprecated global config root_restrict_files "
          "must be an array of strings\n");
      *enforcing = false;
      return NULL;
    }
    if (!ignore_watchmanconfig) {
      prepend_watchmanconfig_to_array(ref);
    }
    json_incref(ref);
    *enforcing = true;
    return ref;
  }

  // Synthesize our conservative default value.
  // .watchmanconfig MUST be first
  if (!ignore_watchmanconfig) {
    return json_pack("[ssss]", ".watchmanconfig", ".hg", ".git", ".svn");
  } else {
    return json_pack("[sss]", ".hg", ".git", ".svn");
  }
}
Пример #22
0
Value NDKHelper::getValueFromJson(json_t *obj)
{
    if (obj == NULL) {
        return Value::Null;
    }

    if (json_is_object(obj)) {
        ValueMap valueMap;

        const char *key;
        json_t *value;

        void *iter = json_object_iter(obj);
        while (iter) {
            key = json_object_iter_key(iter);
            value = json_object_iter_value(iter);

            valueMap[key] = NDKHelper::getValueFromJson(value);

            iter = json_object_iter_next(obj, iter);
        }

        return Value(valueMap);
    } else if (json_is_array(obj)) {
        ValueVector valueVector;

        size_t sizeArray = json_array_size(obj);

        for (unsigned int i = 0; i < sizeArray; i++) {
            valueVector.push_back(NDKHelper::getValueFromJson(json_array_get(obj, i)));
        }

        return Value(valueVector);
    } else if (json_is_boolean(obj)) {
        if (json_is_true(obj)) {
            return Value(true);
        } else {
            return Value(false);
        }
    } else if (json_is_integer(obj)) {
        int value = (int) json_integer_value(obj);

        return Value(value);
    } else if (json_is_real(obj)) {
        double value = json_real_value(obj);

        return Value(value);
    } else if (json_is_string(obj)) {
        std::string value = json_string_value(obj);

        return Value(value);
    }

    return Value::Null;
}
Пример #23
0
bool Json::getBool(const char *key) const
{
    if (!json_) {
        return false;
    }

    json_t *value = json_object_get(json_, key);
    if (json_is_false(value))
        return false;
    return json_is_true(value) || json_integer_value(value);
}
Пример #24
0
bool json_get_bool_key(const json_t* obj, const char* key) {
    json_t* value = json_object_get(obj, key);
    if (value == NULL) {
        fprintf(stderr, "error: missing required \"%s\" key\n", key);
        exit(1);
    }
    if (!json_is_boolean(value)) {
        fprintf(stderr, "error: \"%s\" key must be a boolean, got %s\n", key, json_strof(value));
        exit(1);
    }
    return json_is_true(value);
}
Пример #25
0
static cxBool jsonToBool(json_t *v,cxBool dv)
{
    CX_RETURN(v == NULL,dv);
    v = jsonParseRegisterValue(v);
    if(json_is_string(v)){
        return strcasecmp(json_string_value(v), "true") == 0;
    }
    if(json_is_integer(v)){
        return json_integer_value(v) != 0;
    }
    return json_is_true(v);
}
Пример #26
0
//## Boolean Json.getBool(String key);
static KMETHOD Json_getBool(KonohaContext *kctx, KonohaStack *sfp)
{
	json_t* obj = ((struct _kJson *)sfp[0].asObject)->obj;
	CHECK_JSON(obj, KReturnUnboxValue(false));
	const char *key = S_text(sfp[1].asString);
	json_t* json = json_object_get(obj, key);
	kbool_t ret = false;
	if(json_is_true(json)) {
		ret = true;
	}
	KReturnUnboxValue(ret);
}
Пример #27
0
int jansson_to_val(pv_value_t* val, char** freeme, json_t* v) {

	val->flags = 0;

	if(json_is_object(v) || json_is_array(v)) {
		const char* value = json_dumps(v, JSON_COMPACT|JSON_PRESERVE_ORDER);
		*freeme = (char*)value;
		val->rs.s = (char*)value;
		val->rs.len = strlen(value);
		val->flags = PV_VAL_STR;
	}else if(json_is_string(v)) {
		const char* value = json_string_value(v);
		val->rs.s = (char*)value;
		val->rs.len = strlen(value);
		val->flags = PV_VAL_STR;
	}else if(json_is_boolean(v)) {
		val->ri = json_is_true(v) ? 0 : 1;
		val->flags = PV_TYPE_INT|PV_VAL_INT;
	}else if(json_is_real(v)) {
		char* value = NULL;
		if(asprintf(&value, "%.15g", json_real_value(v))<0) {
			ERR("asprintf failed\n");
			return -1;
		}
		*freeme = value;
		val->rs.s = value;
		val->rs.len = strlen(value);
		val->flags = PV_VAL_STR;
	}else if(json_is_integer(v)) {
		long long value = json_integer_value(v);
		if ((value > INT_MAX) || (value < INT_MIN))  {
			char* svalue = NULL;
			if (asprintf(&svalue, "%"JSON_INTEGER_FORMAT, value) < 0) {
				ERR("asprintf failed\n");
				return -1;
			}
			*freeme = svalue;
			val->rs.s = svalue;
			val->rs.len = strlen(svalue);
			val->flags = PV_VAL_STR;
		} else {
			val->ri = (int)value;
			val->flags = PV_TYPE_INT|PV_VAL_INT;
		}
	}else if(json_is_null(v)) {
		val->flags = PV_VAL_NULL;
	}else {
		ERR("unrecognized json type: %d\n", json_typeof(v));
		return -1;
	}
	return 0;
}
Пример #28
0
bool cfg_get_bool(w_root_t *root, const char *name, bool defval)
{
  json_t *val = cfg_get_json(root, name);

  if (val) {
    if (!json_is_boolean(val)) {
      w_log(W_LOG_FATAL, "Expected config value %s to be a boolean\n", name);
    }
    return json_is_true(val);
  }

  return defval;
}
Пример #29
0
void BinWriter::writeConstructor(json_t *jconstructor)
{
    writeMethodBase(jconstructor);

    if (json_is_true(json_object_get(jconstructor, "defaultconstructor")))
    {
        bytes.writeBoolean(true);
    }
    else
    {
        bytes.writeBoolean(false);
    }
}
Пример #30
0
static bool stratum_notify_m7(struct stratum_ctx *sctx, json_t *params)
{
    const char *job_id, *prevblock, *accroot, *merkleroot, *version, *ntime;
    int height;
    bool clean;

    job_id = json_string_value(json_array_get(params, 0));
    prevblock = json_string_value(json_array_get(params, 1));
    accroot = json_string_value(json_array_get(params, 2));
    merkleroot = json_string_value(json_array_get(params, 3));
    height = json_integer_value(json_array_get(params, 4));
    version = json_string_value(json_array_get(params, 5));
    ntime = json_string_value(json_array_get(params, 6));
    clean = json_is_true(json_array_get(params, 7));

    if (!job_id || !prevblock || !accroot || !merkleroot ||
            !version || !height || !ntime ||
            strlen(prevblock) != 32*2 ||
            strlen(accroot) != 32*2 ||
            strlen(merkleroot) != 32*2 ||
            strlen(ntime) != 8*2 || strlen(version) != 2*2) {
        applog(LOG_ERR, "Stratum (M7) notify: invalid parameters");
        return false;
    }

    pthread_mutex_lock(&sctx->work_lock);

    if (!sctx->job.job_id || strcmp(sctx->job.job_id, job_id)) {
        sctx->job.xnonce2 = (unsigned char *)realloc(sctx->job.xnonce2, sctx->xnonce2_size);
        memset(sctx->job.xnonce2, 0, sctx->xnonce2_size);
    }
    free(sctx->job.job_id);
    sctx->job.job_id = strdup(job_id);

    hex2bin(sctx->job.m7prevblock, prevblock, 32);
    hex2bin(sctx->job.m7accroot, accroot, 32);
    hex2bin(sctx->job.m7merkleroot, merkleroot, 32);
    be64enc(sctx->job.m7height, height);
    hex2bin(sctx->job.m7version, version, 2);
    hex2bin(sctx->job.m7ntime, ntime, 8);
    sctx->job.clean = clean;

    sctx->job.diff = sctx->next_diff;

    pthread_mutex_unlock(&sctx->work_lock);

    return true;
}