static void parse_config(const char *fn, char *s)
{
struct parse_state state;
next_token(&state);
int kw = lookup_keyword(args[0]);
parse_new_section(&state, kw, nargs, args);
{
// case K_service: set service handle action
// add service into list
state->context = parse_service(state, nargs, args);
{
struct service *svc;
list_init(&svc->onrestart.commands);
list_add_tail(&service_list, &svc->slist);
}
// case K_on:
// add action into list
state->context = parse_action(state, nargs, args);
{
list_add_tail(&action_list, &act->alist);
}
}
}
static mrb_value
mrb_ipvs_service_init(mrb_state *mrb, mrb_value self){
int parse;
mrb_value arg_opt = mrb_nil_value(),
addr = mrb_nil_value(),
proto = mrb_nil_value(),
sched_name = mrb_nil_value(),
ops = mrb_nil_value(),
obj = mrb_nil_value();
mrb_int port,
timeout,
netmask;
struct mrb_ipvs_entry *ie;
ie = (struct mrb_ipvs_entry*)mrb_malloc(mrb, sizeof(*ie));
memset(ie, 0, sizeof(struct mrb_ipvs_entry));
mrb_get_args(mrb, "H", &arg_opt);
if (mrb_nil_p(arg_opt)) mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
addr = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "addr"));
if (mrb_nil_p(addr)) mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
proto = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "protocol"));
if (mrb_nil_p(proto)) proto = mrb_str_new_cstr(mrb, DEF_PROTO);
sched_name = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "sched_name"));
if (mrb_nil_p(sched_name)) sched_name = mrb_str_new_cstr(mrb, DEF_SCHED);
obj = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "port"));
port = mrb_nil_p(obj) ? 0 : mrb_fixnum(obj);
if (port < 0 || port > 65535) mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
ops = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "ops"));
timeout = mrb_fixnum(mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "timeout")));
netmask = mrb_fixnum(mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "netmask")));
ie->svc.protocol = parse_proto((char *) RSTRING_PTR(proto));
parse = parse_service((char *) RSTRING_PTR(addr), &ie->svc);
if (strrchr((char *) RSTRING_PTR(addr), ':') == NULL) ie->svc.port = htons(port);
if (!(parse & SERVICE_ADDR))
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
strncpy(ie->svc.sched_name, (char *) RSTRING_PTR(sched_name), IP_VS_SCHEDNAME_MAXLEN);
DATA_TYPE(self) = &mrb_ipvs_service_type;
DATA_PTR(self) = ie;
return self;
}
static mrb_value
mrb_ipvs_dest_init(mrb_state *mrb, mrb_value self){
int parse;
mrb_value arg_opt = mrb_nil_value(),
addr = mrb_nil_value(),
obj = mrb_nil_value();
mrb_int port,
weight;
struct mrb_ipvs_entry *ie;
ie = (struct mrb_ipvs_entry*)mrb_malloc(mrb, sizeof(*ie));
memset(ie, 0, sizeof(struct mrb_ipvs_entry));
mrb_get_args(mrb, "H", &arg_opt);
if (mrb_nil_p(arg_opt)) mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
addr = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "addr"));
if (mrb_nil_p(addr)) mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
obj = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "port"));
port = mrb_nil_p(obj) ? 0 : mrb_fixnum(obj);
if (port < 0 || port > 65535) mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid port value specified");
weight = mrb_fixnum(mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "weight")));
obj = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "weight"));
weight = mrb_nil_p(obj) ? DEF_WEIGHT : mrb_fixnum(obj);
if (weight < 0 || weight > INT_MAX) mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid weight value specified");
if (strrchr((char *) RSTRING_PTR(addr), ':') == NULL) ie->svc.port = htons(port);
parse = parse_service((char *) RSTRING_PTR(addr), &ie->svc);
if (!(parse & SERVICE_ADDR))
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "@service"), mrb_nil_value());
ie->dest.af = ie->svc.af;
ie->dest.addr = ie->svc.addr;
ie->dest.port = ie->svc.port;
ie->dest.weight = weight;
DATA_TYPE(self) = &mrb_ipvs_dest_type;
DATA_PTR(self) = ie;
return self;
}
static gboolean
read_service_file (xmlTextReaderPtr reader, AgService *service)
{
const xmlChar *name;
int ret;
ret = xmlTextReaderRead (reader);
while (ret == 1)
{
name = xmlTextReaderConstName (reader);
if (G_LIKELY (name &&
strcmp ((const gchar *)name, "service") == 0))
{
return parse_service (reader, service);
}
ret = xmlTextReaderNext (reader);
}
return FALSE;
}
static void
parseconfig ()
{
str cf = configfile;
parseargs pa (cf);
bool errors = false;
str hostname;
rpc_ptr<sfs_hash> hostid;
server *s = NULL;
release *r = NULL;
extension *e = NULL;
char *c;
int line;
vec<str> av;
while (pa.getline (&av, &line)) {
if (!strcasecmp (av[0], "BindAddr")) {
in_addr addr;
u_int16_t port = 0;
if (av.size () < 2 || av.size () > 3
|| !inet_aton (av[1], &addr)
|| (av.size () == 3 && !convertint (av[2], &port))) {
warn << cf << ":" << line
<< ": usage: BindAddr addr [port]\n";
errors = true;
continue;
}
if (!port)
port = sfs_defport ? sfs_defport : SFS_PORT;
sockaddr_in *sinp
= static_cast<sockaddr_in *> (xmalloc (sizeof (*sinp)));
bzero (sinp, sizeof (*sinp));
sinp->sin_family = AF_INET;
sinp->sin_port = htons (port);
sinp->sin_addr = addr;
#ifdef HAVE_SA_LEN
sinp->sin_len = sizeof (*sinp);
#endif /* HAVE_SA_LEN */
listenaddrs.push_back (reinterpret_cast<sockaddr *> (sinp));
}
else if (!strcasecmp (av[0], "Server")) {
if (av.size () != 2) {
warn << cf << ":" << line
<< ": usage: Server {hostname|*}[:hostid]\n";
errors = true;
continue;
}
if (strchr (av[1], ':') ||
((c = strchr (av[1], '@')) && strchr (c, ','))) {
hostid.alloc ();
if (!sfs_parsepath (av[1], &hostname, hostid)) {
warn << cf << ":" << line << ": bad hostname/hostid\n";
errors = true;
continue;
}
}
else {
hostid.clear ();
if (av[1] == "*")
hostname = sfshostname ();
else
hostname = av[1];
}
for (s = serverlist.first; s; s = serverlist.next (s))
if (hostname == s->host
&& ((hostid && s->hostid && *hostid == *s->hostid)
|| (!hostid && !s->hostid)))
break;
if (!s)
s = New server (hostname, hostid);
r = NULL;
e = NULL;
}
else if (!strcasecmp (av[0], "Release")) {
static rxx relrx ("^(\\d+)\\.(\\d\\d?)$");
if (av.size () != 2 || (!relrx.search (av[1]) && av[1] != "*")) {
warn << cf << ":" << line << ": usage Release { N.NN | * }\n";
errors = true;
r = NULL;
continue;
}
if (!s) {
warn << cf << ":" << line << ": Release must follow Server\n";
errors = true;
r = NULL;
continue;
}
u_int32_t rel;
if (av[1] == "*")
rel = 0xffffffff;
else
rel = strtoi64 (relrx[1]) * 100 + strtoi64 (relrx[2]);
r = s->reltab[rel];
if (!r)
s->reltab.insert ((r = New release (rel)));
for (e = r->extlist.first; r->extlist.next (e); e = r->extlist.next (e))
;
}
else if (!strcasecmp (av[0], "Extensions")) {
av.pop_front ();
e = r->getext (av);
}
else if (!strcasecmp (av[0], "Service")) {
if (!parse_service (av, e, cf << ":" << line))
errors = true;
}
else if (!strcasecmp (av[0], "HashCost")) {
if (av.size () != 2 || !convertint (av[1], &sfs_hashcost)) {
warn << cf << ":" << line << ": usage: HashCost <nbits>\n";
errors = true;
}
else {
if (sfs_hashcost > sfs_maxhashcost)
sfs_hashcost = sfs_maxhashcost;
str s (strbuf ("SFS_HASHCOST=%d", sfs_hashcost));
xputenv (const_cast<char*>(s.cstr()));
}
}
else if (!strcasecmp (av[0], "RevocationDir")) {
if (av.size () != 2) {
warn << cf << ":" << line << ": usage: RevocationDir <directory>\n";
errors = true;
}
else {
revocationdir = av[1];
}
}
else {
errors = true;
warn << cf << ":" << line << ": unknown directive '"
<< av[0] << "'\n";
}
}
if (errors)
fatal ("parse errors in configuration file\n");
}
static mrb_value mrb_ipvs_service_init(mrb_state *mrb, mrb_value self) {
int parse;
mrb_value arg_opt = mrb_nil_value(), addr = mrb_nil_value(),
proto = mrb_nil_value(), sched_name = mrb_nil_value(),
obj = mrb_nil_value();
// mrb_value arg_opt = mrb_nil_value(), addr = mrb_nil_value(),
// proto = mrb_nil_value(), sched_name = mrb_nil_value(),
// ops = mrb_nil_value(), obj = mrb_nil_value();
mrb_int port;
// mrb_int port, timeout, netmask;
struct mrb_ipvs_service *ie;
ie = (struct mrb_ipvs_service *)mrb_malloc(mrb, sizeof(*ie));
memset(ie, 0, sizeof(struct mrb_ipvs_service));
mrb_get_args(mrb, "H", &arg_opt);
if (mrb_nil_p(arg_opt)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
addr = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "addr"));
if (mrb_nil_p(addr)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
obj = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "port"));
port = mrb_nil_p(obj) ? 0 : mrb_fixnum(obj);
if (port < 0 || port > 65535) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid port value specified");
}
proto = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "protocol"));
if (mrb_nil_p(proto)) {
proto = mrb_str_new_cstr(mrb, DEF_PROTO);
}
sched_name = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "sched_name"));
if (mrb_nil_p(sched_name)) {
sched_name = mrb_str_new_cstr(mrb, DEF_SCHED);
}
// ops = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "ops"));
// timeout =
// mrb_fixnum(mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb,
// "timeout")));
// netmask =
// mrb_fixnum(mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb,
// "netmask")));
ie->svc.protocol = parse_proto((char *)RSTRING_PTR(proto));
parse = parse_service((char *)RSTRING_PTR(addr), &ie->svc);
if (strrchr((char *)RSTRING_PTR(addr), ':') == NULL) {
ie->svc.port = htons(port);
}
if (!(parse & SERVICE_ADDR)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
strncpy(ie->svc.sched_name, (char *)RSTRING_PTR(sched_name),
IP_VS_SCHEDNAME_MAXLEN);
mrb_data_init(self, ie, &mrb_ipvs_service_type);
return self;
}
int get_rls(const str_t *uri, xcap_query_params_t *xcap_params,
const str_t *package, flat_list_t **dst)
{
char *data = NULL;
int dsize = 0;
service_t *service = NULL;
char *xcap_uri = NULL;
str_t *filename = NULL;
int res;
if (!dst) return RES_INTERNAL_ERR;
/* get basic document */
xcap_uri = xcap_uri_for_global_document(xcap_doc_rls_services,
filename, xcap_params);
if (!xcap_uri) {
ERROR_LOG("can't get XCAP uri\n");
return RES_XCAP_QUERY_ERR;
}
res = xcap_query(xcap_uri, xcap_params, &data, &dsize);
if (res != 0) {
ERROR_LOG("XCAP problems for uri \'%s\'\n", xcap_uri);
if (data) {
cds_free(data);
}
cds_free(xcap_uri);
return RES_XCAP_QUERY_ERR;
}
cds_free(xcap_uri);
/* parse document as a service element in rls-sources */
if (parse_service(data, dsize, &service) != 0) {
ERROR_LOG("Parsing problems!\n");
if (service) free_service(service);
if (data) {
cds_free(data);
}
return RES_XCAP_PARSE_ERR;
}
/* DEBUG_LOG("%.*s\n", dsize, data);*/
if (data) cds_free(data);
if (!service) {
DEBUG_LOG("Empty service!\n");
return RES_XCAP_QUERY_ERR;
}
/* verify the package */
if (verify_package(service, package) != 0) {
free_service(service);
return RES_BAD_EVENT_PACKAGE_ERR;
}
/* create flat document */
res = create_flat_list(service, xcap_params, dst);
if (res != RES_OK) {
ERROR_LOG("Flat list creation error\n");
free_service(service);
free_flat_list(*dst);
*dst = NULL;
return res;
}
free_service(service);
return RES_OK;
}
