static gboolean
local_validate (UmAccountDialog *self)
{
        gboolean valid_login;
        gboolean valid_name;
        GtkWidget *entry;
        const gchar *name;
        gchar *tip;

        name = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (self->local_username));
        valid_login = is_valid_username (name, &tip);

        entry = gtk_bin_get_child (GTK_BIN (self->local_username));
        if (tip) {
                set_entry_validation_error (GTK_ENTRY (entry), tip);
                g_free (tip);
        } else {
                clear_entry_validation_error (GTK_ENTRY (entry));
        }

        name = gtk_entry_get_text (GTK_ENTRY (self->local_name));
        valid_name = is_valid_name (name);

        return valid_name && valid_login;
}
static void
check_name (gchar **primary_text, gchar **secondary_text, gpointer data)
{
    OobsGroup *group = OOBS_GROUP (data);
    GtkWidget *widget;
    const gchar *name;

    widget = gst_dialog_get_widget (tool->main_dialog, "group_settings_name");
    name = gtk_entry_get_text (GTK_ENTRY (widget));

    if (strlen (name) < 1) {
        *primary_text = g_strdup (_("Group name is empty"));
        *secondary_text = g_strdup (_("A group name must be specified."));
    } else if (is_group_root (group) && strcmp (name, "root") != 0) {
        *primary_text = g_strdup (_("Group name of the administrator group user should not be modified"));
        *secondary_text = g_strdup (_("This would leave the system unusable."));
    } else if (!is_valid_name (name)) {
        *primary_text = g_strdup (_("Group name has invalid characters"));
        *secondary_text = g_strdup (_("Please set a valid group name consisting of "
                                      "a lower case letter followed by lower case "
                                      "letters and numbers."));
    } else if (group_settings_dialog_group_is_new () && group_exists (name)) {
        *primary_text = g_strdup_printf (_("Group \"%s\" already exists"), name);
        *secondary_text = g_strdup (_("Please select a different user name."));
    }
}
Esempio n. 3
0
static void name_map(char *OutName, BOOL need83, BOOL cache83, int default_case, int snum)
{
	smb_ucs2_t *OutName_ucs2;
	magic_char = lp_magicchar(snum);

	DEBUG(5,("name_map( %s, need83 = %s, cache83 = %s)\n", OutName,
		 need83 ? "True" : "False", cache83 ? "True" : "False"));
	
	if (push_ucs2_allocate(&OutName_ucs2, OutName) == (size_t)-1) {
		DEBUG(0, ("push_ucs2_allocate failed!\n"));
		return;
	}

	if( !need83 && !NT_STATUS_IS_OK(is_valid_name(OutName_ucs2, False, False)))
		need83 = True;

	/* check if it's already in 8.3 format */
	if (need83 && !NT_STATUS_IS_OK(is_8_3_w(OutName_ucs2, False))) {
		char *tmp = NULL; 

		/* mangle it into 8.3 */
		if (cache83)
			tmp = SMB_STRDUP(OutName);

		to_8_3(OutName, default_case);

		if(tmp != NULL) {
			cache_mangled_name(OutName, tmp);
			SAFE_FREE(tmp);
		}
	}

	DEBUG(5,("name_map() ==> [%s]\n", OutName));
	SAFE_FREE(OutName_ucs2);
}
Esempio n. 4
0
void account_create_operation::validate()const
{
   FC_ASSERT( fee.amount >= 0 );
   FC_ASSERT( is_valid_name( name ) );
   FC_ASSERT( referrer_percent <= GRAPHENE_100_PERCENT );
   FC_ASSERT( owner.num_auths() != 0 );
   FC_ASSERT( owner.address_auths.size() == 0 );
   FC_ASSERT( active.num_auths() != 0 );
   FC_ASSERT( active.address_auths.size() == 0 );
   FC_ASSERT( !owner.is_impossible(), "cannot create an account with an imposible owner authority threshold" );
   FC_ASSERT( !active.is_impossible(), "cannot create an account with an imposible active authority threshold" );
   options.validate();
   if( extensions.value.owner_special_authority.valid() )
      validate_special_authority( *extensions.value.owner_special_authority );
   if( extensions.value.active_special_authority.valid() )
      validate_special_authority( *extensions.value.active_special_authority );
   if( extensions.value.buyback_options.valid() )
   {
      FC_ASSERT( !(extensions.value.owner_special_authority.valid()) );
      FC_ASSERT( !(extensions.value.active_special_authority.valid()) );
      FC_ASSERT( owner == authority::null_authority() );
      FC_ASSERT( active == authority::null_authority() );
      size_t n_markets = extensions.value.buyback_options->markets.size();
      FC_ASSERT( n_markets > 0 );
      for( const asset_id_type m : extensions.value.buyback_options->markets )
      {
         FC_ASSERT( m != extensions.value.buyback_options->asset_to_buy );
      }
   }
}
Esempio n. 5
0
/**
 * g_dbus_is_interface_name:
 * @string: The string to check.
 *
 * Checks if @string is a valid D-Bus interface name.
 *
 * Returns: %TRUE if valid, %FALSE otherwise.
 *
 * Since: 2.26
 */
gboolean
g_dbus_is_interface_name (const gchar *string)
{
  guint len;
  gboolean ret;
  const gchar *s;
  const gchar *end;

  g_return_val_if_fail (string != NULL, FALSE);

  ret = FALSE;

  len = strlen (string);
  if (G_UNLIKELY (len == 0 || len > 255))
    goto out;

  s = string;
  end = s + len;
  if (G_UNLIKELY (*s == '.'))
    {
      /* can't start with a . */
      goto out;
    }
  else if (G_UNLIKELY (!is_valid_initial_bus_name_character (*s, FALSE, FALSE)))
    goto out;

  ret = is_valid_name (s + 1, len - 1, FALSE, FALSE);

 out:
  return ret;
}
Esempio n. 6
0
/**
 * g_dbus_is_unique_name:
 * @string: The string to check.
 *
 * Checks if @string is a valid D-Bus unique bus name.
 *
 * Returns: %TRUE if valid, %FALSE otherwise.
 *
 * Since: 2.26
 */
gboolean
g_dbus_is_unique_name (const gchar *string)
{
  gboolean ret;
  guint len;

  g_return_val_if_fail (string != NULL, FALSE);

  ret = FALSE;

  len = strlen (string);
  if (G_UNLIKELY (len == 0 || len > 255))
    goto out;

  if (G_UNLIKELY (*string != ':'))
    goto out;

  if (G_UNLIKELY (!is_valid_name (string + 1, len - 1, TRUE, TRUE)))
    goto out;

  ret = TRUE;

 out:
  return ret;
}
Esempio n. 7
0
/*
 * drop a bucket with a specified name,
 * no return value, check log when you find something wrong
 */
void bucket_drop(const char *name) {

    if (!is_valid_name(name))
        return;

    struct bucket *bucket;
    pthread_rwlock_wrlock(&rwlock);
    HASH_FIND_STR(buckets, name, bucket);
    if (bucket) {
        /* TODO: find and delete all data on hard disk belongs to this bucket */
        /* TODO: find and delete all request in write queue belongs to this bucket */
        while (bucket->tables) {
            HASH_DEL(bucket->tables, bucket->tables);
        }
        HASH_DEL(buckets, bucket);
    }
    // close_storage(bucket->bsp);
    char link_from[1024];

    snprintf(link_from, sizeof(link_from), "%s.schema", name);
    if (unlink(link_from) != 0)
        log_error("unlink %s failed: %s", link_from, strerror(errno));

    snprintf(link_from, sizeof(link_from), "%s/schema", name);
    if (unlink(link_from) != 0)
        log_error("unlink %s failed: %s", link_from, strerror(errno));

    pthread_rwlock_unlock(&rwlock);
}
Esempio n. 8
0
void
impl::Stats::add(const std::string& name, const StatBase& stat)
{
    assert(_stats.find(name) == _stats.end());
    assert(is_valid_name(name));
    _stats[name] = &stat;
}
Esempio n. 9
0
/* static */
void GeneratorRegistry::register_factory(const std::string &name,
                                         std::unique_ptr<GeneratorFactory> factory) {
    user_assert(is_valid_name(name)) << "Invalid Generator name: " << name;
    GeneratorRegistry &registry = get_registry();
    std::lock_guard<std::mutex> lock(registry.mutex);
    internal_assert(registry.factories.find(name) == registry.factories.end())
        << "Duplicate Generator name: " << name;
    registry.factories[name] = std::move(factory);
}
static gboolean
enterprise_validate (UmAccountDialog *self)
{
        const gchar *name;
        gboolean valid_name;
        gboolean valid_domain;
        GtkTreeIter iter;

        name = gtk_entry_get_text (GTK_ENTRY (self->enterprise_login));
        valid_name = is_valid_name (name);

        if (gtk_combo_box_get_active_iter (self->enterprise_domain, &iter)) {
                gtk_tree_model_get (gtk_combo_box_get_model (self->enterprise_domain),
                                    &iter, 0, &name, -1);
        } else {
                name = gtk_entry_get_text (self->enterprise_domain_entry);
        }

        valid_domain = is_valid_name (name);
        return valid_name && valid_domain;
}
Esempio n. 11
0
bool is_valid_user_name (const char *name)
{
	/*
	 * User names are limited by whatever utmp can
	 * handle.
	 */
	if (strlen (name) > USER_NAME_MAX_LENGTH) {
		return false;
	}

	return is_valid_name (name);
}
gboolean
gis_account_page_enterprise_validate (GisAccountPageEnterprise *page)
{
  const gchar *name;
  gboolean valid_name;
  gboolean valid_domain;
  GtkTreeIter iter;
  GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page);

  name = gtk_entry_get_text (GTK_ENTRY (priv->login));
  valid_name = is_valid_name (name);

  if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (priv->domain), &iter)) {
    gtk_tree_model_get (gtk_combo_box_get_model (GTK_COMBO_BOX (priv->domain)),
                        &iter, 0, &name, -1);
  } else {
    name = gtk_entry_get_text (GTK_ENTRY (priv->domain_entry));
  }

  valid_domain = is_valid_name (name);
  return valid_name && valid_domain;
}
Esempio n. 13
0
bool is_valid_group_name (const char *name)
{
	/*
	 * Arbitrary limit for group names.
	 * HP-UX 10 limits to 16 characters
	 */
	if (   (GROUP_NAME_MAX_LENGTH > 0)
	    && (strlen (name) > GROUP_NAME_MAX_LENGTH)) {
		return false;
	}

	return is_valid_name (name);
}
Esempio n. 14
0
/**
 * g_dbus_is_name:
 * @string: The string to check.
 *
 * Checks if @string is a valid D-Bus bus name (either unique or well-known).
 *
 * Returns: %TRUE if valid, %FALSE otherwise.
 *
 * Since: 2.26
 */
gboolean
g_dbus_is_name (const gchar *string)
{
  guint len;
  gboolean ret;
  const gchar *s;

  g_return_val_if_fail (string != NULL, FALSE);

  ret = FALSE;

  len = strlen (string);
  if (G_UNLIKELY (len == 0 || len > 255))
    goto out;

  s = string;
  if (*s == ':')
    {
      /* handle unique name */
      if (!is_valid_name (s + 1, len - 1, TRUE, TRUE))
        goto out;
      ret = TRUE;
      goto out;
    }
  else if (G_UNLIKELY (*s == '.'))
    {
      /* can't start with a . */
      goto out;
    }
  else if (G_UNLIKELY (!is_valid_initial_bus_name_character (*s, FALSE, TRUE)))
    goto out;

  ret = is_valid_name (s + 1, len - 1, FALSE, TRUE);

 out:
  return ret;
}
Esempio n. 15
0
void GeneratorBase::build_params() {
    if (!params_built) {
        std::vector<void *> vf = ObjectInstanceRegistry::instances_in_range(
            this, size, ObjectInstanceRegistry::FilterParam);
        for (size_t i = 0; i < vf.size(); ++i) {
            Parameter *param = static_cast<Parameter *>(vf[i]);
            internal_assert(param != nullptr);
            user_assert(param->is_explicit_name()) << "Params in Generators must have explicit names: " << param->name();
            user_assert(is_valid_name(param->name())) << "Invalid Param name: " << param->name();
            for (const Argument& arg : filter_arguments) {
                user_assert(arg.name != param->name()) << "Duplicate Param name: " << param->name();
            }
            Expr def, min, max;
            if (!param->is_buffer()) {
                def = param->get_scalar_expr();
                min = param->get_min_value();
                max = param->get_max_value();
            }
            filter_arguments.push_back(Argument(param->name(),
                param->is_buffer() ? Argument::InputBuffer : Argument::InputScalar,
                param->type(), param->dimensions(), def, min, max));
        }

        std::vector<void *> vg = ObjectInstanceRegistry::instances_in_range(
            this, size, ObjectInstanceRegistry::GeneratorParam);
        for (size_t i = 0; i < vg.size(); ++i) {
            GeneratorParamBase *param = static_cast<GeneratorParamBase *>(vg[i]);
            internal_assert(param != nullptr);
            user_assert(is_valid_name(param->name)) << "Invalid GeneratorParam name: " << param->name;
            user_assert(generator_params.find(param->name) == generator_params.end())
                << "Duplicate GeneratorParam name: " << param->name;
            generator_params[param->name] = param;
        }
        params_built = true;
    }
}
Esempio n. 16
0
void declaration(ecc_context *ctx, const char *token)
{
	ctx->lex_advance(ctx, str_nlen(token, TOKEN_MAX));
	token = ctx->lex_look_ahead(ctx);
	if (!(is_valid_name(token))) {
		err_msg("token '");
		err_msg(token);
		err_msg("' not a valid name\n");
		die();
	}
	ctx->stack_assign_name(ctx, token);
	token = ctx->lex_look_ahead(ctx);
	if (!(is_declaration(token))) {
		done_declaring(ctx);
	}
}
Esempio n. 17
0
static bool must_mangle(const char *name,
			const struct share_params *p)
{
	smb_ucs2_t *name_ucs2 = NULL;
	NTSTATUS status;
	size_t converted_size;
	char magic_char;

	magic_char = lp_magicchar(p);

	if (!push_ucs2_talloc(NULL, &name_ucs2, name, &converted_size)) {
		DEBUG(0, ("push_ucs2_talloc failed!\n"));
		return False;
	}
	status = is_valid_name(name_ucs2, False, False);
	TALLOC_FREE(name_ucs2);
	return NT_STATUS_IS_OK(status);
}
Esempio n. 18
0
static bool must_mangle(const char *name,
			const struct share_params *p)
{
	smb_ucs2_t *name_ucs2 = NULL;
	NTSTATUS status;
	size_t converted_size;

	if (!push_ucs2_talloc(NULL, &name_ucs2, name, &converted_size)) {
		DEBUG(0, ("push_ucs2_talloc failed!\n"));
		return False;
	}
	status = is_valid_name(name_ucs2, False, False);
	TALLOC_FREE(name_ucs2);
	/* We return true if we *must* mangle, so if it's
	 * a valid name (status == OK) then we must return
	 * false. Bug #6939. */
	return !NT_STATUS_IS_OK(status);
}
Esempio n. 19
0
/*
 * returns a string containing all bucket name
 * returns NULL if it fails
 */
char *bucket_list(void) {
    /* load buckets from filesystem */
    int size;
    int pos = 0;
    char *result;
    struct bucket *bucket;
    int len;

    DIR *dir = opendir(".");
    if (dir) {
        struct dirent *dirent;
        while ((dirent = readdir(dir))) {
            if ((dirent->d_type & DT_DIR) && is_valid_name(dirent->d_name))
                bucket_get(dirent->d_name, CAN_RETURN_NULL);
        }
        closedir(dir);
    }


    pthread_rwlock_rdlock(&rwlock);
    
    size = len = 0;
    for (bucket = buckets; bucket; bucket = (struct bucket *)bucket->hh.next) {
        len = strlen(bucket->name) + 1;
        size += len;
    }

    result = slab_alloc(size);
    if (!result)
        return NULL;

    size = len = 0;
    for (bucket = buckets; bucket; bucket = (struct bucket *)bucket->hh.next) {
        len = strlen(bucket->name) + 1;
        size += len;
        memcpy(result + pos, bucket->name, len);
        pos = size;
    }

    pthread_rwlock_unlock(&rwlock);
    result[pos] = '\0';
    return result;
}
Esempio n. 20
0
static NTSTATUS is_8_3_w(const smb_ucs2_t *fname, bool allow_wildcards)
{
	smb_ucs2_t *pref = 0, *ext = 0;
	size_t plen;
	NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;

	if (!fname || !*fname)
		return NT_STATUS_INVALID_PARAMETER;

	if (strlen_w(fname) > 12)
		return NT_STATUS_UNSUCCESSFUL;

	if (strcmp_wa(fname, ".") == 0 || strcmp_wa(fname, "..") == 0)
		return NT_STATUS_OK;

	/* Name cannot start with '.' */
	if (*fname == UCS2_CHAR('.'))
		return NT_STATUS_UNSUCCESSFUL;

	if (!NT_STATUS_IS_OK(is_valid_name(fname, allow_wildcards, True)))
		goto done;

	if (!NT_STATUS_IS_OK(mangle_get_prefix(fname, &pref, &ext, allow_wildcards)))
		goto done;
	plen = strlen_w(pref);

	if (strchr_wa(pref, '.'))
		goto done;
	if (plen < 1 || plen > 8)
		goto done;
	if (ext && (strlen_w(ext) > 3))
		goto done;

	ret = NT_STATUS_OK;

done:
	SAFE_FREE(pref);
	SAFE_FREE(ext);
	return ret;
}
Esempio n. 21
0
int schema_field_add(struct schema *schema, const char *name, bool is_signed, uint8_t nbits, bool is_primary_key) {
    if (schema->nfields == sizeof(schema->fields) / sizeof(schema->fields[0]))
        return -1;
        
    if (nbits > 64)
        return -5;
        
    if (nbits == 64 && is_signed)
        return -6;
        
    if (schema_field_get(schema, name))
        return -2;
    
    if (!is_valid_name(name))
        return -8;
    
    size_t name_len = strlen(name);
    struct field *field = &schema->fields[schema->nfields];
    
    if (name_len + 1 > sizeof(field->name))
        return -3;
    
    strcpy(field->name, name);
    field->is_signed = is_signed;
    field->offset = schema->nbits;
    field->nbits = nbits;
    
    if (is_primary_key && schema->primary_key_index != -1)
        return -7;
    
    field->is_primary_key = is_primary_key;
    if (is_primary_key)
        schema->primary_key_index = schema->nfields;
    
    schema->nbits += nbits;
    schema->nfields++;
    
    return 0;
}
Esempio n. 22
0
static bool hash_name_to_8_3(const char *in,
			char out[13],
			bool cache83,
			int default_case,
			const struct share_params *p)
{
	smb_ucs2_t *in_ucs2 = NULL;
	size_t converted_size;
	char magic_char;

	magic_char = lp_magicchar(p);

	DEBUG(5,("hash_name_to_8_3( %s, cache83 = %s)\n", in,
		 cache83 ? "True" : "False"));

	if (!push_ucs2_talloc(NULL, &in_ucs2, in, &converted_size)) {
		DEBUG(0, ("push_ucs2_talloc failed!\n"));
		return False;
	}

	/* If it's already 8.3, just copy. */
	if (NT_STATUS_IS_OK(is_valid_name(in_ucs2, False, False)) &&
				NT_STATUS_IS_OK(is_8_3_w(in_ucs2, False))) {
		TALLOC_FREE(in_ucs2);
		strlcpy(out, in, 13);
		return True;
	}

	TALLOC_FREE(in_ucs2);
	if (!to_8_3(magic_char, in, out, default_case)) {
		return False;
	}

	cache_mangled_name(out, in);

	DEBUG(5,("hash_name_to_8_3(%s) ==> [%s]\n", in, out));
	return True;
}
Esempio n. 23
0
bool account_name_eq_lit_predicate::validate()const
{
   return is_valid_name( name );
}
Esempio n. 24
0
/*
 * returns a pointer to a schema, or NULL if fails
 */
static struct schema *schema_create_from_hash(uint64_t hash, const char *bucket_name) {
    struct schema *schema = NULL;
    char buf[1024];
    snprintf(buf, sizeof(buf), "%s/schemas/%016"PRIx64, bucket_name, hash);
    log_notice("read schema from file [%s]", buf);
    FILE *f = fopen(buf, "r");
    if (f == NULL) {
        // legacy file path
        snprintf(buf, sizeof(buf), "schemas/%016"PRIx64, hash);        
        log_notice("read schema from file [%s]", buf);
        f = fopen(buf, "r");
    }

    if (f == NULL) {
        log_notice("read schema failed");
        return NULL;
    }
    
    schema = schema_create();
    if (!schema) {
        log_error("can't create schema");
        goto fail;
    }

    while (fgets(buf, sizeof(buf), f)) {
        char *saveptr;
        char *token = strtok_r(buf, " \n\r\t", &saveptr);
        
        uint8_t is_primary_key = 0;
        uint8_t is_signed = 0;
        char *name = NULL;
        uint16_t nbits = 0;
                
        if (strcmp(token, "upgrade_to") == 0) {
            token = next_token(&saveptr);
            if (token == NULL)
                goto fail;
            if (sscanf(token, "%"SCNx64, &schema->upgrade_to) != 1)
                goto fail;
            if (schema->upgrade_to == 0)
                goto fail;
        }
        else {

            /* backward compat */
            if (strcmp(token, "field") == 0)
                token = next_token(&saveptr);

            while (token) {
                if (token[0] >= '1' && token[1] <= '9')
                    nbits = atoi(token);
                else if (strcmp(token, "primary_key") == 0)
                    is_primary_key = 1;
                else if (strcmp(token, "signed") == 0)
                    is_signed = 1;
                else if (token[0] == '[') { // field name
                    size_t len = strlen(token);
                    if (token[len - 1] == ']') {
                        token[len - 1] = '\0';
                        name = &token[1];
                        if (!is_valid_name(name))
                            goto fail;
                    }
                    else
                        goto fail;
                }
                else
                    goto fail;
                
                token = next_token(&saveptr);
            }

            int res = schema_field_add(schema, name, is_signed, nbits, is_primary_key);
            if (res != 0)
                goto fail;
        }
    }
    fclose(f);
    schema->hash = hash;
    return schema;

fail:
    fclose(f);
    if (schema)
        slab_free(schema);
    log_error("schema file %016"PRIx64" is invalid", hash);
    return NULL;
}
Esempio n. 25
0
/*
	gather data from UI to internal representation
*/
bool TframTag::ValidateView()
{
	PTAG_NAME name;
	PRTK_TAG tag;	
	name = &m_TagName;
	tag = &m_Tag;
	
	try{
	#undef cc

	#define cc(name) tag->s.Flags |= (chk##name->Checked ? TF_##name : 0);

		if( edtTagName->Text.Length() >sizeof(TAG_KEY) ||
			!edtTagName->Text.Length()
		){
			m_Hint = "变量名不正确";
			throw(-1);
		}
		if( !is_valid_name(edtTagName->Text.c_str()) ){
			m_Hint = "变量名只能包含字母、数字和下划线";
			throw(-3);
		}
		if(edtTagName->Text.Length() > sizeof(TAG_KEY)){		
			m_Hint = AnsiString("错误: 标签名不能超过 ") + IntToStr(sizeof(TAG_KEY)) + " 个字节";		 
			throw(-3);
		}
		name->sname.tag = CTagName(edtTagName->Text.c_str());
		tag->s.Device = CDeviceName(cmbDevice->Text.c_str());
		tag->key = name->sname.tag;
		if(edtCName->Text.Length() > sizeof(tag->s.Description)){
			m_Hint = "中文名太长(最长 " + AnsiString(sizeof(tag->s.Description)/2) + " 字)";
			throw(-4);
		}
		strncpy(tag->s.Description, edtCName->Text.c_str(), sizeof(tag->s.Description));
		tag->s.Description[sizeof(tag->s.Description) - 1] = 0;
		if(edtAddr->Text.Length() > sizeof(tag->s.Address)){
			m_Hint = "地址太长(最长 " + AnsiString(sizeof(tag->s.Address)/2) + " 字)";
			throw(-5);
		}
		strncpy(tag->s.Address, edtAddr->Text.c_str(), sizeof(tag->s.Address));
		tag->s.Address[sizeof(tag->s.Address) - 1] = 0;

        tag->s.Flags = 0;
        
		switch(cmbType->ItemIndex){
		case 0:
			set_value_type(tag->s.Flags, dt_bool);
			break;
		case 1:
			set_value_type(tag->s.Flags, dt_real4);
			break;
		case 2:
			set_value_type(tag->s.Flags, dt_real8);
			break;

		case 3:
			set_value_type(tag->s.Flags, dt_int8);
			break;
		case 4:
			set_value_type(tag->s.Flags, dt_int16);
			break;
		case 5:
			set_value_type(tag->s.Flags, dt_int32);
			break;
		case 6:
			set_value_type(tag->s.Flags, dt_int64);
			break;

		case 7:
			set_value_type(tag->s.Flags, dt_uint8);
			break;
		case 8:
			set_value_type(tag->s.Flags, dt_uint16);
			break;
		case 9:
			set_value_type(tag->s.Flags, dt_uint32);
			break;
		case 10:
			set_value_type(tag->s.Flags, dt_uint64);
			break;

        case 11:
            set_value_type(tag->s.Flags, dt_date);
            break;

        case 12:
            m_Hint = "不支持这个数据类型.";
            throw(-41);
            break;
		}

		cc(SaveToHistory);
        cc(Step);

		// collecting common analog attributes
		switch(get_value_type(tag->s.Flags)){
        case dt_int8:
		case dt_int16:
		case dt_int32:
        case dt_int64:
        case dt_uint8:
		case dt_uint16:
		case dt_uint32:
        case dt_uint64:
        case dt_real4:
		case dt_real8:
        case dt_date:
			cc(HiHi);
			cc(Lo);
			cc(Hi);
			cc(LoLo);
			cc(Rate);
			strncpy(
				tag->s.AnalogMsg.EU,
				edtEU->Text.c_str(),
				sizeof(tag->s.AnalogMsg.EU)
				);
			tag->s.AnalogMsg.EU[sizeof(tag->s.AnalogMsg.EU) - 1] = 0;
			break;
		case dt_bool:
			cc(On2Off);
			cc(Off2On);
			
			strncpy(
				tag->s.SwitchMsg.OnMsg,
				edtOnMessage->Text.c_str(),
				sizeof(tag->s.SwitchMsg.OnMsg)
				);
			tag->s.SwitchMsg.OnMsg[sizeof(tag->s.SwitchMsg.OnMsg) - 1] = 0;
			strncpy(
				tag->s.SwitchMsg.OffMsg,
				edtOffMessage->Text.c_str(),
				sizeof(tag->s.SwitchMsg.OffMsg)
				);
			tag->s.SwitchMsg.OffMsg[sizeof(tag->s.SwitchMsg.OffMsg) - 1] = 0;
			break;
		}

#define get(msg, name, ignore_on_condition, _default_value)\
	m_Hint = msg;\
	if( !edt##name->Text.Length() ){\
		if(ignore_on_condition){\
			tag->s.flt##name = _default_value;\
		}else{\
			throw(-1);\
		}\
	}else{\
		tag->s.flt##name = edt##name->Text.ToDouble();\
	}
#pragma warn -ccc
#pragma warn -rch
		switch(get_value_type(tag->s.Flags)){
		case dt_real4:
		case dt_real8:
			get("高高值不正确", HiHi, !chkHiHi->Checked, 0);
			get("低低值不正确", LoLo, !chkLoLo->Checked, 0);
			get("低值不正确", Lo, !chkLo->Checked, 0);
			get("高值不正确", Hi, !chkHi->Checked, 0);
			get("报警死区值不正确", AlarmDeadband, !(tag->s.Flags & 0xffffff00), 0);
			get("最大值不正确", MaxValue, false, 0);
			get("最小值不正确", MinValue, false, 0);
			get("速率报警阈值不正确", Rate, !chkRate->Checked, 0.1);
			break;

		case dt_int8:
		case dt_int16:
		case dt_int32:
        case dt_int64:
		case dt_uint8:
		case dt_uint16:
		case dt_uint32:
        case dt_uint64:
			get("速率报警阈值不正确", Rate, !chkRate->Checked, 0.1);
#undef get
#define get(msg, attrName, uiName, ignore_on_condition, _default_value)\
	m_Hint = msg;\
	if( !edt##uiName->Text.Length() ){\
		if(ignore_on_condition){\
			tag->s.##attrName = _default_value;\
		}else{\
			throw(-1);\
		}\
	}else{\
		tag->s.attrName = edt##uiName->Text.ToDouble();\
	}
			get("高高值不正确", u_hihi.i, HiHi, !chkHiHi->Checked, 0);
			get("低低值不正确", u_lolo.i, LoLo, !chkLoLo->Checked, 0);
			get("低值不正确", u_lo.i, Lo, !chkLo->Checked, 0);
			get("高值不正确", u_hi.i, Hi, !chkHi->Checked, 0);
			get("报警死区值不正确", u_deadband.i, AlarmDeadband, !(tag->s.Flags & 0xffffff00), 0);
			get("最大值不正确", u_max.i, MaxValue, false, 0);
			get("最小值不正确", u_min.i, MinValue, false, 0);
			break;
		}

#pragma warn .ccc
#pragma warn .rch

        if(get_value_type(tag->s.Flags) == dt_bool){
            tag->s.AlarmRank = edtAlarmRank2->Text.ToInt();
        }else{
    		tag->s.AlarmRank = edtAlarmRank->Text.ToInt();
        }

		tag->s.Compressing = Compress_Const;
		tag->s.CompDev = StrToFloat(edtCompDev->Text);
		tag->s.CompMax = StrToInt(edtCompMax->Text);
	}catch(...){
		return false;
	}
	m_Hint = "更新成功";
	return true;
}
Esempio n. 26
0
/*
 * get a bucket with the specified name,
 * if it does not exits, create it implicitly,
 * returns a pointer to the bucket on success,
 * returns NULL if it fails
 */
struct bucket *bucket_get(const char *name, int flags) {
    if (!is_valid_name(name)) {
        log_warn("invalid bucket name: [%s]", name);
        return NULL;
    }
    
    struct bucket *bucket;
    pthread_rwlock_rdlock(&rwlock);
    int wrlocked = 0;
again:
    HASH_FIND_STR(buckets, name, bucket);
    if (bucket == NULL) {
        if (wrlocked == 0) {
            pthread_rwlock_unlock(&rwlock);
            pthread_rwlock_wrlock(&rwlock);
            wrlocked = 1;
            goto again;
        }
        
        // find schema before malloc
        struct schema *schema = schema_get_latest(name);
        if (schema == NULL && (flags & CAN_RETURN_NULL))
            goto done;
        
        if (mkdir(name, 0755) == -1) {
            log_error("mkdir failed: %s", strerror(errno));
            if (errno != EEXIST)
                goto done;
        }

        bucket = (struct bucket *)slab_alloc(sizeof(struct bucket));
        /* XXX: free the schema that no one can be sure if it's referenced by others */
        if (!bucket) {
            log_error("can't alloc bucket %s", name);
            goto done;
        }

        memset(bucket, 0, sizeof(struct bucket));
        pthread_rwlock_init(&bucket->rwlock, NULL);

        size_t namelen = strlen(name);
        char filename[namelen + 4];
        memcpy(filename, name, namelen);
        memcpy(filename + namelen, ".db", 4);

        if (open_storage(filename, 100 * 1024 * 1024, &bucket->bsp) != 0) {
            log_error("open_storage failed");
            pthread_rwlock_destroy(&bucket->rwlock);
            slab_free(bucket);
            pthread_rwlock_unlock(&rwlock);
            return NULL;
        }

        strncpy(bucket->name, name, sizeof(bucket->name));
        bucket->schema = schema;
        bucket->tables = NULL;
        HASH_ADD_STR(buckets, name, bucket);

        if (schema)
            schema_save_to_file(schema, bucket->name);
    }
done:
    pthread_rwlock_unlock(&rwlock);
    
    return bucket;
}