void DHCPv6::vendor_info(const vendor_info_type &value) {
std::vector<uint8_t> buffer(sizeof(uint32_t) + value.data.size());
uint32_t enterprise_number = Endian::host_to_be(value.enterprise_number);
std::memcpy(&buffer[0], &enterprise_number, sizeof(uint32_t));
std::copy(
value.data.begin(),
value.data.end(),
buffer.begin() + sizeof(uint32_t)
);
add_option(
option(VENDOR_OPTS, buffer.begin(), buffer.end())
);
}
/* response.options MUST be free_options()ed! */
CTP_STATUS_t
get_STATUS(textbuf *buf)
{
client_t *c;
char id_buf[sizeof(client->id) + 1] = { 0 };
CTP_STATUS_t response;
/* XXX TODO set response.checksum */
response.options = new_options();
/* build list of peers in options */
for (c = clients; c <= max_active_client; ++c) {
if (c->active) {
memcpy(id_buf, &c->id, sizeof(c->id));
add_option(response.options, "Peer ID", id_buf);
/* TODO Peer Nick? */
if (c->state == Locked)
add_option(response.options, "Lock ID", id_buf);
}
}
return response;
}
void DHCPv6::server_id(const duid_type &value) {
serialization_type buffer(sizeof(uint16_t) + value.data.size());
uint16_t tmp_id = Endian::host_to_be(value.id);
std::memcpy(&buffer[0], &tmp_id, sizeof(uint16_t));
std::copy(
value.data.begin(),
value.data.end(),
buffer.begin() + sizeof(uint16_t)
);
add_option(
option(SERVERID, buffer.begin(), buffer.end())
);
}
void DHCPv6::ia_ta(const ia_ta_type &value) {
std::vector<uint8_t> buffer(sizeof(uint32_t) + value.options.size());
uint32_t *ptr = (uint32_t*)&buffer[0];
*ptr++ = Endian::host_to_be(value.id);
std::copy(
value.options.begin(),
value.options.end(),
buffer.begin() + sizeof(uint32_t)
);
add_option(
option(IA_TA, buffer.begin(), buffer.end())
);
}
void DHCPv6::status_code(const status_code_type &value) {
std::vector<uint8_t> buffer(sizeof(uint16_t) + value.message.size());
uint16_t uint16_t_buffer = Endian::host_to_be(value.code);
std::memcpy(&buffer[0], &uint16_t_buffer, sizeof(uint16_t));
std::copy(
value.message.begin(),
value.message.end(),
buffer.begin() + sizeof(uint16_t)
);
add_option(
option(STATUS_CODE, buffer.begin(), buffer.end())
);
}
static char* add_fuse_options(char* options, const char* spec)
{
options = add_option(options, "fsname", spec);
if (options == NULL)
return NULL;
options = add_user_option(options);
if (options == NULL)
return NULL;
options = add_blksize_option(options, CLUSTER_SIZE(*ef.sb));
if (options == NULL)
return NULL;
return options;
}
void DHCPv6::option_request(const option_request_type &value) {
typedef option_request_type::const_iterator iterator;
std::vector<uint8_t> buffer(value.size() * sizeof(uint16_t));
size_t index = 0;
uint16_t uint16_t_buffer;
for(iterator it = value.begin(); it != value.end(); ++it, index += 2) {
uint16_t_buffer = Endian::host_to_be<uint16_t>(*it);
std::memcpy(&buffer[index], &uint16_t_buffer, sizeof(uint16_t));
}
add_option(
option(OPTION_REQUEST, buffer.begin(), buffer.end())
);
}
void
ObjectSettings::add_path_ref(const std::string& text, const std::string& path_ref, const std::string& key,
unsigned int flags)
{
add_option(std::make_unique<PathRefObjectOption>(text, path_ref, key, flags));
if (!path_ref.empty()) {
m_options.erase(std::remove_if(m_options.begin(), m_options.end(),
[](const std::unique_ptr<ObjectOption>& obj) {
return obj->get_key() == "x" || obj->get_key() == "y";
}),
m_options.end());
}
}
/* register an enumeration option array, NOTE: all enumeration option variables
must be of type `int', since true enum variables may be allocated with
variable sizes by some compilers */
void
opt_reg_enum_list(struct opt_odb_t *odb,/* option data base */
char *name, /* option name */
char *desc, /* option description */
int *vars, /* target array */
int nvars, /* target array size */
int *nelt, /* number of args parsed goes here */
char *def_val, /* default variable value */
char **emap, /* enumeration string map */
int *eval, /* enumeration value map, optional */
int emap_sz, /* size of maps */
int print, /* print during `-dumpconfig'? */
char *format, /* option value print format */
int accrue) /* accrue list across uses */
{
int i, enum_val;
struct opt_opt_t *opt;
opt = (struct opt_opt_t *)calloc(1, sizeof(struct opt_opt_t));
if (!opt)
fatal("out of virtual memory");
opt->name = mystrdup(name);
opt->desc = desc;
opt->nvars = nvars;
opt->nelt = nelt;
opt->format = format ? format : "%s";
opt->oc = oc_enum;
opt->variant.for_enum.var = vars;
opt->variant.for_enum.emap = emap;
opt->variant.for_enum.eval = eval;
opt->variant.for_enum.emap_sz = emap_sz;
if (def_val)
{
if (!bind_to_enum(def_val, emap, eval, emap_sz, &enum_val))
fatal("could not bind default value for option `%s'", name);
}
else
enum_val = 0;
opt->print = print;
opt->accrue = accrue;
/* place on ODB's option list */
opt->next = NULL;
add_option(odb, opt);
/* set default value */
for (i=0; i < *nelt; i++)
vars[i] = enum_val;
}
void anjuta_cvs_update (AnjutaPlugin *obj, const gchar* filename, gboolean recurse,
gboolean prune, gboolean create, gboolean reset_sticky, const gchar* revision, GError **err)
{
GString* options = g_string_new("");
CVSPlugin* plugin = ANJUTA_PLUGIN_CVS (obj);
gchar* command;
add_option(!recurse, options, "-l");
add_option(prune, options, "-P");
add_option(create, options, "-d");
if (strlen(revision))
{
g_string_append_printf(options, " -r %s", revision);
}
else
{
add_option(reset_sticky, options, "-A");
}
if (!is_directory(filename))
{
gchar* file = g_strdup(filename);
command = create_cvs_command(anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
NULL), "update", options->str, basename(file));
cvs_execute(plugin, command, dirname(file));
g_free(file);
}
else
{
gchar* dir = g_strdup(filename);
command = create_cvs_command(anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
NULL), "update", options->str, "");
cvs_execute(plugin, command, dir);
}
g_free(command);
g_string_free(options, TRUE);
}
void DHCPv6::vendor_class(const vendor_class_type &value) {
std::vector<uint8_t> buffer(
sizeof(uint32_t)
);
*(uint32_t*)&buffer[0] = Endian::host_to_be(value.enterprise_number);
class_option_data2option(
value.vendor_class_data.begin(),
value.vendor_class_data.end(),
buffer,
sizeof(uint32_t)
);
add_option(
option(VENDOR_CLASS, buffer.begin(), buffer.end())
);
}
static char* add_blksize_option(char* options, long cluster_size)
{
long page_size = 0;
char blksize[20];
#ifdef _SC_PAGESIZE
page_size = sysconf(_SC_PAGESIZE);
#endif
if (page_size < 1)
page_size = 0x1000;
snprintf(blksize, sizeof(blksize), "%ld", MIN(page_size, cluster_size));
return add_option(options, "blksize", blksize);
}
/* register an enumeration option variable, NOTE: all enumeration option
variables must be of type `int', since true enum variables may be allocated
with variable sizes by some compilers */
void
opt_reg_enum(struct opt_odb_t *odb, /* option data base */
char *name, /* option name */
char *desc, /* option description */
int *var, /* target variable */
char *def_val, /* default variable value */
char **emap, /* enumeration string map */
int *eval, /* enumeration value map, optional */
int emap_sz, /* size of maps */
int print, /* print during `-dumpconfig'? */
char *format) /* option value print format */
{
int enum_val;
#ifndef FIX_8_CLUSTER_BUG
struct opt_opt_t *opt = NULL;
#endif
opt = (struct opt_opt_t *)calloc(1, sizeof(struct opt_opt_t));
if (!opt)
fatal("out of virtual memory");
opt->name = name;
opt->desc = desc;
opt->nvars = 1;
opt->nelt = NULL;
opt->format = format ? format : "%12s";
opt->oc = oc_enum;
opt->variant.for_enum.var = var;
opt->variant.for_enum.emap = emap;
opt->variant.for_enum.eval = eval;
opt->variant.for_enum.emap_sz = emap_sz;
if (def_val)
{
if (!bind_to_enum(def_val, emap, eval, emap_sz, &enum_val))
fatal("could not bind default value for option `%s'", name);
}
else
enum_val = 0;
opt->print = print;
opt->accrue = FALSE;
/* place on ODB's option list */
opt->next = NULL;
add_option(odb, opt);
/* set default value */
*var = enum_val;
}
void ICMPv6::parse_options(const uint8_t *&buffer, uint32_t &total_sz) {
while(total_sz > 0) {
if(total_sz < 8 || (static_cast<uint32_t>(buffer[1]) * 8) > total_sz || buffer[1] < 1)
throw malformed_packet();
// size(option) = option_size - identifier_size - length_identifier_size
add_option(
option(
buffer[0],
static_cast<uint32_t>(buffer[1]) * 8 - sizeof(uint8_t) * 2,
buffer + 2
)
);
total_sz -= buffer[1] * 8;
buffer += buffer[1] * 8;
}
}
static char* add_user_option(char* options)
{
struct passwd* pw;
if (getuid() == 0)
return options;
pw = getpwuid(getuid());
if (pw == NULL || pw->pw_name == NULL)
{
free(options);
exfat_error("failed to determine username");
return NULL;
}
return add_option(options, "user", pw->pw_name);
}
/* parse a set of debugging option specifications and add them to the option list */
static void parse_options( const char *str )
{
char *opt, *next, *options;
unsigned int i;
if (!(options = strdup(str))) return;
for (opt = options; opt; opt = next)
{
const char *p;
unsigned char set = 0, clear = 0;
if ((next = strchr( opt, ',' ))) *next++ = 0;
p = opt + strcspn( opt, "+-" );
if (!p[0]) p = opt; /* assume it's a debug channel name */
if (p > opt)
{
for (i = 0; i < sizeof(debug_classes)/sizeof(debug_classes[0]); i++)
{
int len = strlen(debug_classes[i]);
if (len != (p - opt)) continue;
if (!memcmp( opt, debug_classes[i], len )) /* found it */
{
if (*p == '+') set |= 1 << i;
else clear |= 1 << i;
break;
}
}
if (i == sizeof(debug_classes)/sizeof(debug_classes[0])) /* bad class name, skip it */
continue;
}
else
{
if (*p == '-') clear = ~0;
else set = ~0;
}
if (*p == '+' || *p == '-') p++;
if (!p[0]) continue;
if (!strcmp( p, "all" ))
default_flags = (default_flags & ~clear) | set;
else
add_option( p, set, clear );
}
free( options );
}
void DHCPv6::authentication(const authentication_type &value) {
std::vector<uint8_t> buffer(
sizeof(uint8_t) * 3 + sizeof(uint64_t) + value.auth_info.size()
);
buffer[0] = value.protocol;
buffer[1] = value.algorithm;
buffer[2] = value.rdm;
*(uint64_t*)&buffer[3] = Endian::host_to_be(value.replay_detection);
std::copy(
value.auth_info.begin(),
value.auth_info.end(),
buffer.begin() + sizeof(uint8_t) * 3 + sizeof(uint64_t)
);
add_option(
option(AUTH, buffer.begin(), buffer.end())
);
}
void DHCPv6::ia_address(const ia_address_type &value) {
std::vector<uint8_t> buffer(
sizeof(uint32_t) * 2 + ipaddress_type::address_size + value.options.size()
);
uint32_t *ptr = (uint32_t*)&buffer[ipaddress_type::address_size];
value.address.copy(&buffer[0]);
*ptr++ = Endian::host_to_be(value.preferred_lifetime);
*ptr++ = Endian::host_to_be(value.valid_lifetime);
std::copy(
value.options.begin(),
value.options.end(),
buffer.begin() + sizeof(uint32_t) * 2 + ipaddress_type::address_size
);
add_option(
option(IA_ADDR, buffer.begin(), buffer.end())
);
}
SETUP()
{
static int option_changed;
optval_t val;
init_options(&option_changed);
val.str_val = "";
cpoptions[0] = '\0';
add_option("cpoptions", "cpo", OPT_CHARSET, OPT_GLOBAL,
ARRAY_LEN(cpoptions_charset) - 1, &cpoptions_vals, cpoptions_handler,
val);
val.str_val = "";
add_option("cdpath", "cd", OPT_STRLIST, OPT_GLOBAL, 0, NULL, dummy_handler,
val);
val.bool_val = fastrun = 0;
add_option("fastrun", "fr", OPT_BOOL, OPT_GLOBAL, 0, NULL, fastrun_handler,
val);
value = val.str_val = "fusehome-default";
add_option("fusehome", "fh", OPT_STR, OPT_GLOBAL, 0, NULL, fusehome_handler,
val);
val.enum_item = 1;
add_option("sort", "so", OPT_ENUM, OPT_GLOBAL, ARRAY_LEN(sort_enum),
sort_enum, &dummy_handler, val);
val.bool_val = 1;
add_option("sortorder", "", OPT_BOOL, OPT_GLOBAL, 0, NULL, &dummy_handler,
val);
val.int_val = tabstop = 8;
add_option("tabstop", "ts", OPT_INT, OPT_GLOBAL, 0, NULL, &tabstop_handler,
val);
val.set_items = vifminfo = 0;
add_option("vifminfo", "", OPT_SET, OPT_GLOBAL, ARRAY_LEN(vifminfo_set),
vifminfo_set, &vifminfo_handler, val);
}
static char* add_fsname_option(char* options, const char* spec)
{
/* escaped string cannot be more than twice as big as the original one */
char* escaped = malloc(strlen(spec) * 2 + 1);
if (escaped == NULL)
{
free(options);
exfat_error("failed to allocate escaped string for %s", spec);
return NULL;
}
/* on some platforms (e.g. Android, Solaris) device names can contain
commas */
escape(escaped, spec);
options = add_option(options, "fsname", escaped);
free(escaped);
return options;
}
DHCPv6::DHCPv6(const uint8_t *buffer, uint32_t total_sz)
: options_size()
{
if(total_sz == 0)
throw malformed_packet();
// Relay Agent/Server Messages
bool is_relay_msg = (buffer[0] == 12 || buffer[0] == 13);
uint32_t required_size = is_relay_msg ? 2 : 4;
if(total_sz < required_size)
throw malformed_packet();
std::copy(buffer, buffer + required_size, header_data);
buffer += required_size;
total_sz -= required_size;
if(is_relay_message()) {
if(total_sz < ipaddress_type::address_size * 2)
throw malformed_packet();
link_addr = buffer;
peer_addr = buffer + ipaddress_type::address_size;
buffer += ipaddress_type::address_size * 2;
total_sz -= ipaddress_type::address_size * 2;
}
options_size = total_sz;
while(total_sz) {
if(total_sz < sizeof(uint16_t) * 2)
throw malformed_packet();
uint16_t opt;
std::memcpy(&opt, buffer, sizeof(uint16_t));
opt = Endian::be_to_host(opt);
uint16_t data_size;
std::memcpy(&data_size, buffer + sizeof(uint16_t), sizeof(uint16_t));
data_size = Endian::be_to_host(data_size);
if(total_sz - sizeof(uint16_t) * 2 < data_size)
throw malformed_packet();
buffer += sizeof(uint16_t) * 2;
add_option(
option(opt, buffer, buffer + data_size)
);
buffer += data_size;
total_sz -= sizeof(uint16_t) * 2 + data_size;
}
}
iface_t *get_config(FILE *fp, unsigned int *line, enum itype type)
{
char *var,*val;
struct kopts **opt;
iface_t *ifp;
int ret;
if((ifp = (iface_t *) malloc(sizeof(iface_t))) == NULL) {
*line = 0;
return(NULL);
}
memset((void *) ifp,0,sizeof(iface_t));
ifp->direction = BOTH;
ifp->checksum=-1;
ifp->strict=-1;
ifp->type=type;
/* Set defaults */
switch (type) {
case FILEIO:
flag_set(ifp,F_NOCR);
break;
default:
break;
}
for(opt = &ifp->options;next_config(fp,line,&var,&val) == 0;) {
if (!var)
return(ifp);
if ((ret = add_common_opt(var,val,ifp)) == 0)
continue;
if ((ret < 0) || (((*opt) = add_option(var,val)) == NULL && (ret=-1))) {
if (ret == -1)
*line=0;
break;
}
opt=&(*opt)->next;
}
free_options(ifp->options);
free(ifp);
return(NULL);
}
/* register a boolean flag option array */
void
opt_reg_flag_list(struct opt_odb_t *odb,/* option database */
char *name, /* option name */
char *desc, /* option description */
int *vars, /* pointer to option array */
int nvars, /* total entries in option array */
int *nelt, /* number of elements parsed */
int *def_val, /* default array value */
int print, /* print during `-dumpconfig'? */
char *format, /* optional value print format */
int accrue) /* accrue list across uses */
{
int i;
#ifndef FIX_8_CLUSTER_BUG
struct opt_opt_t *opt = NULL;
#endif
opt = (struct opt_opt_t *)calloc(1, sizeof(struct opt_opt_t));
if (!opt)
fatal("out of virtual memory");
opt->name = name;
opt->desc = desc;
opt->nvars = nvars;
opt->nelt = nelt;
opt->format = format ? format : "%s";
opt->oc = oc_flag;
opt->variant.for_enum.var = vars;
opt->variant.for_enum.emap = flag_emap;
opt->variant.for_enum.eval = flag_eval;
opt->variant.for_enum.emap_sz = NUM_FLAGS;
opt->print = print;
opt->accrue = accrue;
/* place on ODB's option list */
opt->next = NULL;
add_option(odb, opt);
/* set default value */
for (i=0; i < *nelt; i++)
vars[i] = def_val[i];
}
void anjuta_cvs_add (AnjutaPlugin *obj, const gchar* filename,
gboolean binary, GError **err)
{
gchar* command;
CVSPlugin* plugin = ANJUTA_PLUGIN_CVS (obj);
GString* options = g_string_new("");
gchar* file = g_strdup(filename);
add_option(binary, options, "-kb");
command = create_cvs_command(
anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
NULL), "add", options->str, basename(file));
cvs_execute(plugin, command, dirname(file));
g_free(command);
g_free(file);
g_string_free(options, TRUE);
}
Argument( int argc, char** argv ) :
CommandLine( argc, argv )
{
add_help_option();
add_option( "r", "[size_t] Repeat level. ( default : 1 )", 1, false );
add_option( "structure", "[string] kvs::StructuredVolumeObject file path. ( optional )", 1, false );
add_option( "unstructure", "[string] kvs::UnstructuredVolumeObject file path. ( optional )", 1, false );
add_option( "tfunc", "[string] kvs::TransferFunction file path. ( optional )", 1, false );
add_option( "s", "[float] sampling step for PBVR. ( default : 1 )", 1, false );
add_option( "DisableShading", "Disable shading. ( default : eable shading )", 0, false );
if( !this->parse() ) exit( EXIT_FAILURE );
}
int
read_config_file (const char *file, int unit)
{
FILE *fp;
int line_num;
char line[OPTION_LINE_SIZE];
char *p[MAX_PARMS];
int ret = 0;
fp = fopen (file, "r");
if (fp)
{
line_num = 0;
while (fgets(line, sizeof (line), fp))
{
int offset = 0;
CLEAR (p);
++line_num;
/* Ignore UTF-8 BOM at start of stream */
if (line_num == 1 && strncmp (line, "\xEF\xBB\xBF", 3) == 0)
offset = 3;
if (parse_line (line + offset, p, SIZE (p), line_num))
{
bypass_doubledash (&p[0]);
check_inline_file_via_fp (fp, p);
ret |= add_option (p, line_num, unit);
}
}
fclose (fp);
}
else
{
logmessage ("OVPN", "Error opening configuration file");
}
CLEAR (line);
CLEAR (p);
return ret;
}
/* register a double-precision floating point option array */
void
opt_reg_double_list(struct opt_odb_t *odb, /* option data base */
char *name, /* option name */
char *desc, /* option description */
double *vars, /* target array */
int nvars, /* target array size */
int *nelt, /* number of args parsed goes here */
double *def_val, /* default variable value */
int print, /* print during `-dumpconfig'? */
char *format, /* option value print format */
int accrue) /* accrue list across uses */
{
int i;
#ifndef FIX_8_CLUSTER_BUG
struct opt_opt_t *opt = NULL;
#endif
opt = (struct opt_opt_t *)calloc(1, sizeof(struct opt_opt_t));
if (!opt)
fatal("out of virtual memory");
opt->name = name;
opt->desc = desc;
opt->nvars = nvars;
opt->nelt = nelt;
opt->format = format ? format : "%.4f";
opt->oc = oc_double;
opt->variant.for_double.var = vars;
opt->print = print;
opt->accrue = accrue;
/* place on ODB's option list */
opt->next = NULL;
add_option(odb, opt);
/* set default value */
for (i=0; i < *nelt; i++)
vars[i] = def_val[i];
}
int cmdlineopt(struct kopts **options, char *arg)
{
char *val,*ptr;
struct kopts *optr;
for (val=arg;*val && *val != '=';val++);
if (*val != '=') {
logerr(0,"Badly formatted option %s\n",arg);
return(-1);
}
for(*val++ = '\0',ptr=val;*ptr;ptr++);
if ((optr=add_option(arg,val)) == NULL) {
logerr(errno,"Failed to add option");
return(-1);
}
optr->next=*options;
*options=optr;
return(0);
}
EditCommand::EditCommand
( string const& p_command_word,
vector<string> const& p_aliases
):
Command
( p_command_word,
p_aliases,
"Open the activity log or configuration file in a text editor",
vector<HelpLine>
{ HelpLine
( "Open the activity log in a text editor; the editor used is "
"determined by the \"editor\" configuration setting"
)
},
false
)
{
add_option
( 'c',
"Instead of opening the activity log, open the configuration file",
&m_open_config_file
);
}
void anjuta_cvs_commit (AnjutaPlugin *obj, const gchar* filename, const gchar* log,
const gchar* rev, gboolean recurse, GError **err)
{
GString* options = g_string_new("");
CVSPlugin* plugin = ANJUTA_PLUGIN_CVS (obj);
gchar* command;
if (strlen(log))
g_string_printf(options, "-m '%s'", log);
else
g_string_printf(options, "-m 'no log message'");
if (strlen(rev))
{
g_string_append_printf(options, " -r %s", rev);
}
add_option(!recurse, options, "-l");
if (!is_directory(filename))
{
gchar* file = g_strdup(filename);
command = create_cvs_command(anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
NULL), "commit", options->str, basename(file));
cvs_execute(plugin, command, dirname(file));
g_free(file);
}
else
{
gchar* dir = g_strdup(filename);
command = create_cvs_command(anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
NULL), "commit", options->str, "");
cvs_execute(plugin, command, dir);
g_free(dir);
}
g_free(command);
g_string_free(options, TRUE);
}
