static int parse_layer4(struct packet *packet, u8 *layer4_start,
int layer4_protocol, int layer4_bytes,
u8 *packet_end, bool *is_inner, char **error)
{
if (layer4_protocol == IPPROTO_TCP) {
*is_inner = true; /* found inner-most layer 4 */
return parse_tcp(packet, layer4_start, layer4_bytes, packet_end,
error);
} else if (layer4_protocol == IPPROTO_UDP) {
*is_inner = true; /* found inner-most layer 4 */
return parse_udp(packet, layer4_start, layer4_bytes, packet_end,
error);
} else if (layer4_protocol == IPPROTO_ICMP) {
*is_inner = true; /* found inner-most layer 4 */
return parse_icmpv4(packet, layer4_start, layer4_bytes,
packet_end, error);
} else if (layer4_protocol == IPPROTO_ICMPV6) {
*is_inner = true; /* found inner-most layer 4 */
return parse_icmpv6(packet, layer4_start, layer4_bytes,
packet_end, error);
} else if (layer4_protocol == IPPROTO_GRE) {
*is_inner = false;
return parse_gre(packet, layer4_start, layer4_bytes, packet_end,
error);
} else if (layer4_protocol == IPPROTO_IPIP) {
*is_inner = false;
return parse_ipv4(packet, layer4_start, packet_end, error);
} else if (layer4_protocol == IPPROTO_IPV6) {
*is_inner = false;
return parse_ipv6(packet, layer4_start, packet_end, error);
}
return PACKET_UNKNOWN_L4;
}
static int parse_layer3_packet(struct packet *packet,
u8 *header_start, u8 *packet_end,
char **error)
{
u8 *p = header_start;
/* Note that packet_end points to the byte beyond the end of packet. */
struct ipv4 *ip = NULL;
/* Examine IPv4/IPv6 header. */
if (p + sizeof(struct ipv4) > packet_end) {
asprintf(error, "IP header overflows packet");
return PACKET_BAD;
}
/* Look at the IP version number, which is in the first 4 bits
* of both IPv4 and IPv6 packets.
*/
ip = (struct ipv4 *) (p);
if (ip->version == 4)
return parse_ipv4(packet, p, packet_end, error);
else if (ip->version == 6)
return parse_ipv6(packet, p, packet_end, error);
asprintf(error, "Unsupported IP version");
return PACKET_BAD;
}
static int parse_layer3_packet_by_proto(struct packet *packet,
u16 proto, u8 *header_start,
u8 *packet_end, char **error)
{
u8 *p = header_start;
if (proto == ETHERTYPE_IP) {
struct ipv4 *ip = NULL;
/* Examine IPv4 header. */
if (p + sizeof(struct ipv4) > packet_end) {
asprintf(error, "IPv4 header overflows packet");
goto error_out;
}
/* Look at the IP version number, which is in the first 4 bits
* of both IPv4 and IPv6 packets.
*/
ip = (struct ipv4 *)p;
if (ip->version == 4) {
return parse_ipv4(packet, p, packet_end, error);
} else {
asprintf(error, "Bad IP version for ETHERTYPE_IP");
goto error_out;
}
} else if (proto == ETHERTYPE_IPV6) {
struct ipv6 *ip = NULL;
/* Examine IPv6 header. */
if (p + sizeof(struct ipv6) > packet_end) {
asprintf(error, "IPv6 header overflows packet");
goto error_out;
}
/* Look at the IP version number, which is in the first 4 bits
* of both IPv4 and IPv6 packets.
*/
ip = (struct ipv6 *)p;
if (ip->version == 6) {
return parse_ipv6(packet, p, packet_end, error);
} else {
asprintf(error, "Bad IP version for ETHERTYPE_IPV6");
goto error_out;
}
} else if ((proto == ETHERTYPE_MPLS_UC) ||
(proto == ETHERTYPE_MPLS_MC)) {
return parse_mpls(packet, p, packet_end, error);
} else {
return PACKET_UNKNOWN_L4;
}
error_out:
return PACKET_BAD;
}
static grpc_resolver* fake_resolver_create(grpc_resolver_factory* factory,
grpc_resolver_args* args) {
if (0 != strcmp(args->uri->authority, "")) {
gpr_log(GPR_ERROR, "authority based uri's not supported by the %s scheme",
args->uri->scheme);
return NULL;
}
// Get lb_enabled arg. Anything other than "0" is interpreted as true.
const char* lb_enabled_qpart =
grpc_uri_get_query_arg(args->uri, "lb_enabled");
const bool lb_enabled =
lb_enabled_qpart != NULL && strcmp("0", lb_enabled_qpart) != 0;
// Construct addresses.
gpr_slice path_slice =
gpr_slice_new(args->uri->path, strlen(args->uri->path), do_nothing);
gpr_slice_buffer path_parts;
gpr_slice_buffer_init(&path_parts);
gpr_slice_split(path_slice, ",", &path_parts);
grpc_lb_addresses* addresses = grpc_lb_addresses_create(path_parts.count);
bool errors_found = false;
for (size_t i = 0; i < addresses->num_addresses; i++) {
grpc_uri ith_uri = *args->uri;
char* part_str = gpr_dump_slice(path_parts.slices[i], GPR_DUMP_ASCII);
ith_uri.path = part_str;
if (!parse_ipv4(
&ith_uri,
(struct sockaddr_storage*)(&addresses->addresses[i].address.addr),
&addresses->addresses[i].address.len)) {
errors_found = true;
}
gpr_free(part_str);
addresses->addresses[i].is_balancer = lb_enabled;
if (errors_found) break;
}
gpr_slice_buffer_destroy(&path_parts);
gpr_slice_unref(path_slice);
if (errors_found) {
grpc_lb_addresses_destroy(addresses, NULL /* user_data_destroy */);
return NULL;
}
// Instantiate resolver.
fake_resolver* r = gpr_malloc(sizeof(fake_resolver));
memset(r, 0, sizeof(*r));
r->target_name = gpr_strdup(args->uri->path);
r->addresses = addresses;
r->lb_policy_name =
gpr_strdup(grpc_uri_get_query_arg(args->uri, "lb_policy"));
gpr_mu_init(&r->mu);
grpc_resolver_init(&r->base, &fake_resolver_vtable);
return &r->base;
}
/*
parse an ip
*/
bool parse_ip(const char *addr, const char *ifaces, unsigned port, ctdb_sock_addr *saddr)
{
char *p;
bool ret;
ZERO_STRUCTP(saddr); /* valgrind :-) */
/* now is this a ipv4 or ipv6 address ?*/
p = index(addr, ':');
if (p == NULL) {
ret = parse_ipv4(addr, port, &saddr->ip);
} else {
ret = parse_ipv6(addr, ifaces, port, saddr);
}
return ret;
}
static void test_parse_ipv4(const char *uri_text, const char *host,
unsigned short port) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
grpc_resolved_address addr;
char ntop_buf[INET_ADDRSTRLEN];
GPR_ASSERT(1 == parse_ipv4(uri, &addr));
struct sockaddr_in *addr_in = (struct sockaddr_in *)addr.addr;
GPR_ASSERT(AF_INET == addr_in->sin_family);
GPR_ASSERT(NULL != grpc_inet_ntop(AF_INET, &addr_in->sin_addr, ntop_buf,
sizeof(ntop_buf)));
GPR_ASSERT(0 == strcmp(ntop_buf, host));
GPR_ASSERT(ntohs(addr_in->sin_port) == port);
grpc_uri_destroy(uri);
grpc_exec_ctx_finish(&exec_ctx);
}
/* parse ipv4 or ipv6 address
*/
int parse_ip(str *s, struct ip_addr *ip, unsigned short *port)
{
if (!s || !s->len) return -1;
if (memchr(s->s, '.', s->len)) {
/* ipv4 address */
if (parse_ipv4(s, ip, port)) {
LOG(L_ERR, "ERROR: parse_ip(): failed to parse ipv4 iddress: %.*s\n",
s->len, s->s);
return -1;
}
} else {
/* ipv6 address */
if (parse_ipv6(s, ip, port)) {
LOG(L_ERR, "ERROR: parse_ip(): failed to parse ipv6 iddress: %.*s\n",
s->len, s->s);
return -1;
}
}
return 0;
}
int handle_ingress(struct __sk_buff *skb)
{
void *data = (void *)(long)skb->data;
struct ethhdr *eth = data;
void *data_end = (void *)(long)skb->data_end;
uint64_t h_proto, nh_off;
nh_off = sizeof(*eth);
if (data + nh_off > data_end)
return 0;
h_proto = eth->h_proto;
if (h_proto == ETH_P_8021Q || h_proto == ETH_P_8021AD) {
struct vlan_hdr *vhdr;
vhdr = data + nh_off;
nh_off += sizeof(struct vlan_hdr);
if (data + nh_off > data_end)
return 0;
h_proto = vhdr->h_vlan_encapsulated_proto;
}
if (h_proto == ETH_P_8021Q || h_proto == ETH_P_8021AD) {
struct vlan_hdr *vhdr;
vhdr = data + nh_off;
nh_off += sizeof(struct vlan_hdr);
if (data + nh_off > data_end)
return 0;
h_proto = vhdr->h_vlan_encapsulated_proto;
}
if (h_proto == htons(ETH_P_IP))
return parse_ipv4(data, nh_off, data_end);
else if (h_proto == htons(ETH_P_IPV6))
return parse_ipv6(data, nh_off, data_end);
return 0;
}
/****************************************************************************
* Parse from text an IPv4 address range. This can be in one of several
* formats:
* - '192.168.1.1" - a single address
* - '192.168.1.0/24" - a CIDR spec
* - '192.168.1.0-192.168.1.255' - a range
* @param line
* Part of a line of text, probably read from a commandline or conf
* file.
* @param inout_offset
* On input, the offset from the start of the line where the address
* starts. On output, the offset of the first character after the
* range, or equal to 'max' if the line prematurely ended.
* @param max
* The maximum length of the line.
* @return
* The first and last address of the range, inclusive.
****************************************************************************/
struct Range
range_parse_ipv4(const char *line, unsigned *inout_offset, unsigned max)
{
unsigned offset;
struct Range result;
static const struct Range badrange = {0xFFFFFFFF, 0};
int err;
if (inout_offset == NULL) {
inout_offset = &offset;
offset = 0;
max = (unsigned)strlen(line);
} else
offset = *inout_offset;
/* trim whitespace */
while (offset < max && isspace(line[offset]&0xFF))
offset++;
/* get the first IP address */
err = parse_ipv4(line, &offset, max, &result.begin);
if (err) {
return badrange;
}
result.end = result.begin;
/* trim whitespace */
while (offset < max && isspace(line[offset]&0xFF))
offset++;
/* If onely one IP address, return that */
if (offset >= max)
goto end;
/*
* Handle CIDR address of the form "10.0.0.0/8"
*/
if (line[offset] == '/') {
uint64_t prefix = 0;
uint64_t mask = 0;
unsigned digits = 0;
/* skip slash */
offset++;
if (!isdigit(line[offset]&0xFF)) {
return badrange;
}
/* strip leading zeroes */
while (offset<max && line[offset] == '0')
offset++;
/* parse decimal integer */
while (offset<max && isdigit(line[offset]&0xFF)) {
prefix = prefix * 10 + (line[offset++] - '0');
if (++digits > 2)
return badrange;
}
if (prefix > 32)
return badrange;
/* Create the mask from the prefix */
mask = 0xFFFFFFFF00000000ULL >> prefix;
/* Mask off any non-zero bits from the start
* TODO print warning */
result.begin &= mask;
/* Set all suffix bits to 1, so that 192.168.1.0/24 has
* an ending address of 192.168.1.255. */
result.end = result.begin | (unsigned)~mask;
goto end;
}
static int
do_client(int port, const char *ipaddrz)
{
int sockfd;
struct sockaddr_in addr;
struct sigaction sigact;
int i, nwritten;
char databuf[512];
bzero(databuf, sizeof (databuf));
if (parse_ipv4(ipaddrz, &addr) != 0) {
warnx("failed to parse IP address: %s\n", ipaddrz);
return (-1);
}
addr.sin_port = htons(port);
bzero(&sigact, sizeof (sigact));
sigact.sa_sigaction = on_sigpipe;
if (sigaction(SIGPIPE, &sigact, NULL) != 0) {
warn("sigaction");
return (-1);
}
log_time();
(void) printf("connecting to %s port %d\n", ipaddrz, port);
sockfd = make_tcp_socket();
if (sockfd < 0) {
return (-1);
}
if (connect(sockfd, (struct sockaddr *)&addr, sizeof (addr)) != 0) {
warn("connect");
(void) close(sockfd);
return (-1);
}
log_time();
(void) printf("connected\n");
for (i = 0; i < 20; i++) {
log_time();
(void) printf("write (%d)\n", i);
nwritten = write(sockfd, databuf, sizeof (databuf));
if (nwritten != sizeof (databuf)) {
log_time();
if (nwritten < 0) {
(void) printf(
"write returned %d (error %d: %s)\n",
nwritten, errno, strerror(errno));
} else {
(void) printf("write returned %d\n",
nwritten);
}
break;
}
usleep(500000);
}
log_time();
(void) printf("teardown\n");
(void) close(sockfd);
return (0);
}
static grpc_resolver* fake_resolver_create(grpc_exec_ctx* exec_ctx,
grpc_resolver_factory* factory,
grpc_resolver_args* args) {
if (0 != strcmp(args->uri->authority, "")) {
gpr_log(GPR_ERROR, "authority based uri's not supported by the %s scheme",
args->uri->scheme);
return NULL;
}
// Get lb_enabled arg. Anything other than "0" is interpreted as true.
const char* lb_enabled_qpart =
grpc_uri_get_query_arg(args->uri, "lb_enabled");
const bool lb_enabled =
lb_enabled_qpart != NULL && strcmp("0", lb_enabled_qpart) != 0;
// Get the balancer's names.
const char* balancer_names =
grpc_uri_get_query_arg(args->uri, "balancer_names");
grpc_slice_buffer balancer_names_parts;
grpc_slice_buffer_init(&balancer_names_parts);
if (balancer_names != NULL) {
const grpc_slice balancer_names_slice =
grpc_slice_from_copied_string(balancer_names);
grpc_slice_split(balancer_names_slice, ",", &balancer_names_parts);
grpc_slice_unref(balancer_names_slice);
}
// Construct addresses.
grpc_slice path_slice =
grpc_slice_new(args->uri->path, strlen(args->uri->path), do_nothing);
grpc_slice_buffer path_parts;
grpc_slice_buffer_init(&path_parts);
grpc_slice_split(path_slice, ",", &path_parts);
if (balancer_names_parts.count > 0 &&
path_parts.count != balancer_names_parts.count) {
gpr_log(GPR_ERROR,
"Balancer names present but mismatched with number of addresses: "
"%lu balancer names != %lu addresses",
(unsigned long)balancer_names_parts.count,
(unsigned long)path_parts.count);
return NULL;
}
grpc_lb_addresses* addresses =
grpc_lb_addresses_create(path_parts.count, NULL /* user_data_vtable */);
bool errors_found = false;
for (size_t i = 0; i < addresses->num_addresses; i++) {
grpc_uri ith_uri = *args->uri;
char* part_str = grpc_slice_to_c_string(path_parts.slices[i]);
ith_uri.path = part_str;
if (!parse_ipv4(&ith_uri, &addresses->addresses[i].address)) {
errors_found = true;
}
gpr_free(part_str);
if (errors_found) break;
addresses->addresses[i].is_balancer = lb_enabled;
addresses->addresses[i].balancer_name =
balancer_names_parts.count > 0
? grpc_dump_slice(balancer_names_parts.slices[i], GPR_DUMP_ASCII)
: NULL;
}
grpc_slice_buffer_destroy_internal(exec_ctx, &path_parts);
grpc_slice_buffer_destroy_internal(exec_ctx, &balancer_names_parts);
grpc_slice_unref(path_slice);
if (errors_found) {
grpc_lb_addresses_destroy(exec_ctx, addresses);
return NULL;
}
// Instantiate resolver.
fake_resolver* r = gpr_malloc(sizeof(fake_resolver));
memset(r, 0, sizeof(*r));
r->channel_args = grpc_channel_args_copy(args->args);
r->addresses = addresses;
gpr_mu_init(&r->mu);
grpc_resolver_init(&r->base, &fake_resolver_vtable);
return &r->base;
}
static int parse_hostport(int* type, struct ip_addr* ip, unsigned int* port,
cfg_token_t* token, cfg_parser_t* st)
{
int ret;
cfg_token_t t;
cfg_option_t* opt;
ret = cfg_get_token(&t, st, 0);
if (ret < 0) return -1;
if (ret > 0) {
ERR("%s:%d:%d: Missing IP address\n", st->file,
token->start.line, token->start.col);
return -1;
}
if (t.type == '[') {
if (parse_ipv6(ip, &t, st) < 0) return -1;
} else if (t.type == CFG_TOKEN_ALPHA) {
opt = cfg_lookup_token(token_default, &t.val);
if (opt) {
*type = TLS_DOMAIN_DEF;
/* Default domain */
return 0;
} else {
if (parse_ipv4(ip, &t, st) < 0) return -1;
}
} else {
ERR("%s:%d:%d: Syntax error, IP address expected\n",
st->file, t.start.line, t.start.col);
return -1;
}
*type = 0;
/* Parse port */
ret = cfg_get_token(&t, st, 0);
if (ret < 0) return -1;
if (ret > 0) {
ERR("%s:%d:%d: Syntax error, ':' expected\n", st->file, st->line,
st->col);
return -1;
}
if (t.type != ':') {
ERR("%s:%d:%d: Syntax error, ':' expected\n",
st->file, t.start.line, t.start.col);
return -1;
}
ret = cfg_get_token(&t, st, 0);
if (ret < 0) return -1;
if (ret > 0) {
ERR("%s:%d:%d: Premature end of file, port number missing\n",
st->file, t.start.line, t.start.col);
return -1;
}
if (t.type != CFG_TOKEN_ALPHA || (str2int(&t.val, port) < 0)) {
ERR("%s:%d:%d: Invalid port number '%.*s'\n",
st->file, t.start.line, t.start.col, STR_FMT(&t.val));
return -1;
}
return 0;
}
/**
* Simple packet parser: eth, VLAN, IP, TCP/UDP/ICMP
*
* Internal function: caller is resposible for passing only valid packet handles
* , lengths and offsets (usually done&called in packet input).
*
* @param pkt Packet handle
* @param len Packet length in bytes
* @param frame_offset Byte offset to L2 header
*/
void odp_packet_parse(odp_packet_t pkt, size_t len, size_t frame_offset)
{
odp_packet_hdr_t *const pkt_hdr = odp_packet_hdr(pkt);
odp_ethhdr_t *eth;
odp_vlanhdr_t *vlan;
odp_ipv4hdr_t *ipv4;
odp_ipv6hdr_t *ipv6;
uint16_t ethtype;
size_t offset = 0;
uint8_t ip_proto = 0;
pkt_hdr->input_flags.eth = 1;
pkt_hdr->frame_offset = frame_offset;
pkt_hdr->frame_len = len;
if (odp_unlikely(len < ODP_ETH_LEN_MIN)) {
pkt_hdr->error_flags.frame_len = 1;
return;
} else if (len > ODP_ETH_LEN_MAX) {
pkt_hdr->input_flags.jumbo = 1;
}
/* Assume valid L2 header, no CRC/FCS check in SW */
pkt_hdr->input_flags.l2 = 1;
pkt_hdr->l2_offset = frame_offset;
eth = (odp_ethhdr_t *)odp_packet_start(pkt);
ethtype = odp_be_to_cpu_16(eth->type);
vlan = (odp_vlanhdr_t *)ð->type;
if (ethtype == ODP_ETHTYPE_VLAN_OUTER) {
pkt_hdr->input_flags.vlan_qinq = 1;
ethtype = odp_be_to_cpu_16(vlan->tpid);
offset += sizeof(odp_vlanhdr_t);
vlan = &vlan[1];
}
if (ethtype == ODP_ETHTYPE_VLAN) {
pkt_hdr->input_flags.vlan = 1;
ethtype = odp_be_to_cpu_16(vlan->tpid);
offset += sizeof(odp_vlanhdr_t);
}
/* Set l3_offset+flag only for known ethtypes */
switch (ethtype) {
case ODP_ETHTYPE_IPV4:
pkt_hdr->input_flags.ipv4 = 1;
pkt_hdr->input_flags.l3 = 1;
pkt_hdr->l3_offset = frame_offset + ODP_ETHHDR_LEN + offset;
ipv4 = (odp_ipv4hdr_t *)odp_packet_l3(pkt);
ip_proto = parse_ipv4(pkt_hdr, ipv4, &offset);
break;
case ODP_ETHTYPE_IPV6:
pkt_hdr->input_flags.ipv6 = 1;
pkt_hdr->input_flags.l3 = 1;
pkt_hdr->l3_offset = frame_offset + ODP_ETHHDR_LEN + offset;
ipv6 = (odp_ipv6hdr_t *)odp_packet_l3(pkt);
ip_proto = parse_ipv6(pkt_hdr, ipv6, &offset);
break;
case ODP_ETHTYPE_ARP:
pkt_hdr->input_flags.arp = 1;
/* fall through */
default:
ip_proto = 0;
break;
}
switch (ip_proto) {
case ODP_IPPROTO_UDP:
pkt_hdr->input_flags.udp = 1;
pkt_hdr->input_flags.l4 = 1;
pkt_hdr->l4_offset = pkt_hdr->l3_offset + offset;
break;
case ODP_IPPROTO_TCP:
pkt_hdr->input_flags.tcp = 1;
pkt_hdr->input_flags.l4 = 1;
pkt_hdr->l4_offset = pkt_hdr->l3_offset + offset;
break;
case ODP_IPPROTO_SCTP:
pkt_hdr->input_flags.sctp = 1;
pkt_hdr->input_flags.l4 = 1;
pkt_hdr->l4_offset = pkt_hdr->l3_offset + offset;
break;
case ODP_IPPROTO_ICMP:
pkt_hdr->input_flags.icmp = 1;
pkt_hdr->input_flags.l4 = 1;
pkt_hdr->l4_offset = pkt_hdr->l3_offset + offset;
break;
default:
/* 0 or unhandled IP protocols, don't set L4 flag+offset */
if (pkt_hdr->input_flags.ipv6) {
/* IPv6 next_hdr is not L4, mark as IP-option instead */
pkt_hdr->input_flags.ipopt = 1;
}
break;
}
}
static int parse_layer2_packet(struct packet *packet, int in_bytes,
char **error)
{
u8 *p = packet->buffer;
/* Note that packet_end points to the byte beyond the end of packet. */
u8 *packet_end = packet->buffer + in_bytes;
struct ether_header *ether = NULL;
/* Find Ethernet header */
if (p + sizeof(*ether) > packet_end) {
asprintf(error, "Ethernet header overflows packet");
goto error_out;
}
ether = (struct ether_header *)p;
p += sizeof(*ether);
if (ntohs(ether->ether_type) == ETHERTYPE_IP) {
struct ipv4 *ip = NULL;
/* Examine IPv4 header. */
if (p + sizeof(struct ipv4) > packet_end) {
asprintf(error, "IPv4 header overflows packet");
goto error_out;
}
/* Look at the IP version number, which is in the first 4 bits
* of both IPv4 and IPv6 packets.
*/
ip = (struct ipv4 *)p;
if (ip->version == 4) {
return parse_ipv4(packet, p, packet_end, error);
} else {
asprintf(error, "Bad IP version for ETHERTYPE_IP");
goto error_out;
}
} else if (ntohs(ether->ether_type) == ETHERTYPE_IPV6) {
struct ipv6 *ip = NULL;
/* Examine IPv6 header. */
if (p + sizeof(struct ipv6) > packet_end) {
asprintf(error, "IPv6 header overflows packet");
goto error_out;
}
/* Look at the IP version number, which is in the first 4 bits
* of both IPv4 and IPv6 packets.
*/
ip = (struct ipv6 *)p;
if (ip->version == 6) {
return parse_ipv6(packet, p, packet_end, error);
} else {
asprintf(error, "Bad IP version for ETHERTYPE_IPV6");
goto error_out;
}
} else {
return PACKET_UNKNOWN_L4;
}
error_out:
return PACKET_BAD;
}
static bool update_service_property(DBusMessageIter *arg, void *user_data)
{
struct connman_service *service = user_data;
const char *name, *value;
gboolean boolean_value;
char **array;
int length;
if (cui_dbus_get_basic(arg, DBUS_TYPE_STRING, &name) != 0)
return FALSE;
dbus_message_iter_next(arg);
if (g_strcmp0(name, "Name") == 0) {
cui_dbus_get_basic_variant(arg, DBUS_TYPE_STRING, &value);
service->name = g_strdup(value);
} else if (g_strcmp0(name, "Type") == 0) {
cui_dbus_get_basic_variant(arg, DBUS_TYPE_STRING, &value);
service->type = g_strdup(value);
} else if (g_strcmp0(name, "Security") == 0) {
cui_dbus_get_array(arg, DBUS_TYPE_STRING, &length, &array);
g_free(service->security);
if (array != NULL) {
service->security = g_strjoinv(";", array);
g_free(array);
} else
service->security = NULL;
} else if (g_strcmp0(name, "Immutable") == 0) {
cui_dbus_get_basic_variant(arg,
DBUS_TYPE_BOOLEAN, &boolean_value);
service->immutable = boolean_value;
} else if (g_strcmp0(name, PROPERTY(SERVICE_STATE)) == 0) {
cui_dbus_get_basic_variant(arg, DBUS_TYPE_STRING, &value);
service->state = string2enum_state(value);
service->update_index = SERVICE_STATE;
} else if (g_strcmp0(name, PROPERTY(SERVICE_ERROR)) == 0) {
cui_dbus_get_basic_variant(arg, DBUS_TYPE_STRING, &value);
g_free(service->error);
service->error = g_strdup(value);
service->update_index = SERVICE_ERROR;
} else if (g_strcmp0(name, PROPERTY(SERVICE_STRENGTH)) == 0) {
uint8_t uint8_value;
cui_dbus_get_basic_variant(arg, DBUS_TYPE_BYTE, &uint8_value);
service->strength = uint8_value;
service->update_index = SERVICE_STRENGTH;
} else if (g_strcmp0(name, PROPERTY(SERVICE_FAVORITE)) == 0) {
cui_dbus_get_basic_variant(arg,
DBUS_TYPE_BOOLEAN, &boolean_value);
service->favorite = boolean_value;
service->update_index = SERVICE_FAVORITE;
} else if (g_strcmp0(name, PROPERTY(SERVICE_AUTOCONNECT)) == 0) {
cui_dbus_get_basic_variant(arg,
DBUS_TYPE_BOOLEAN, &boolean_value);
service->autoconnect = boolean_value;
service->update_index = SERVICE_AUTOCONNECT;
} else if (g_strcmp0(name, PROPERTY(SERVICE_ROAMING)) == 0) {
cui_dbus_get_basic_variant(arg,
DBUS_TYPE_BOOLEAN, &boolean_value);
service->roaming = boolean_value;
service->update_index = SERVICE_ROAMING;
} else if (g_strcmp0(name, PROPERTY(SERVICE_NAMESERVERS)) == 0) {
cui_dbus_get_array(arg, DBUS_TYPE_STRING, &length, &array);
g_free(service->nameservers);
if (array != NULL) {
service->nameservers = g_strjoinv(";", array);
g_free(array);
} else
service->nameservers = NULL;
service->update_index = SERVICE_NAMESERVERS;
} else if (g_strcmp0(name,
PROPERTY(SERVICE_NAMESERVERS_CONFIGURATION)) == 0) {
cui_dbus_get_array(arg, DBUS_TYPE_STRING, &length, &array);
g_free(service->nameservers_conf);
if (array != NULL) {
service->nameservers_conf = g_strjoinv(";", array);
g_free(array);
} else
service->nameservers_conf = NULL;
service->update_index = SERVICE_NAMESERVERS_CONFIGURATION;
} else if (g_strcmp0(name, PROPERTY(SERVICE_DOMAINS)) == 0) {
cui_dbus_get_array(arg, DBUS_TYPE_STRING, &length, &array);
g_free(service->domains);
if (array != NULL) {
service->domains = g_strjoinv(";", array);
g_free(array);
} else
service->domains = NULL;
service->update_index = SERVICE_DOMAINS;
} else if (g_strcmp0(name,
PROPERTY(SERVICE_DOMAINS_CONFIGURATION)) == 0) {
cui_dbus_get_array(arg, DBUS_TYPE_STRING, &length, &array);
g_free(service->domains_conf);
if (array != NULL) {
service->domains_conf = g_strjoinv(";", array);
g_free(array);
} else
service->domains_conf = NULL;
service->update_index = SERVICE_DOMAINS_CONFIGURATION;
} else if (g_strcmp0(name, PROPERTY(SERVICE_TIMESERVERS)) == 0) {
cui_dbus_get_array(arg, DBUS_TYPE_STRING, &length, &array);
g_free(service->timeservers);
if (array != NULL) {
service->timeservers = g_strjoinv(";", array);
g_free(array);
} else
service->timeservers = NULL;
service->update_index = SERVICE_TIMESERVERS;
} else if (g_strcmp0(name,
PROPERTY(SERVICE_TIMESERVERS_CONFIGURATION)) == 0) {
cui_dbus_get_array(arg, DBUS_TYPE_STRING, &length, &array);
g_free(service->timeservers_conf);
if (array != NULL) {
service->timeservers_conf = g_strjoinv(";", array);
g_free(array);
} else
service->timeservers_conf = NULL;
service->update_index = SERVICE_TIMESERVERS_CONFIGURATION;
} else if (g_strcmp0(name, PROPERTY(SERVICE_IPv4)) == 0) {
service->ipv4 = parse_ipv4(arg, service->ipv4);
service->update_index = SERVICE_IPv4;
} else if (g_strcmp0(name,
PROPERTY(SERVICE_IPv4_CONFIGURATION)) == 0) {
service->ipv4_conf = parse_ipv4(arg, service->ipv4_conf);
service->update_index = SERVICE_IPv4_CONFIGURATION;
} else if (g_strcmp0(name, PROPERTY(SERVICE_IPv6)) == 0) {
service->ipv6 = parse_ipv6(arg, service->ipv6);
service->update_index = SERVICE_IPv6;
} else if (g_strcmp0(name,
PROPERTY(SERVICE_IPv6_CONFIGURATION)) == 0) {
service->ipv6_conf = parse_ipv6(arg, service->ipv6_conf);
service->update_index = SERVICE_IPv6_CONFIGURATION;
} else if (g_strcmp0(name, PROPERTY(SERVICE_PROXY)) == 0) {
service->proxy = parse_proxy(arg, service->proxy);
service->update_index = SERVICE_PROXY;
} else if (g_strcmp0(name,
PROPERTY(SERVICE_PROXY_CONFIGURATION)) == 0) {
service->proxy_conf = parse_proxy(arg, service->proxy_conf);
service->update_index = SERVICE_PROXY_CONFIGURATION;
} else if (g_strcmp0(name, PROPERTY(SERVICE_PROVIDER)) == 0) {
service->provider = parse_provider(arg, service->provider);
service->update_index = SERVICE_PROVIDER;
} else if (g_strcmp0(name, PROPERTY(SERVICE_ETHERNET)) == 0) {
service->ethernet = parse_ethernet(arg, service->ethernet);
service->update_index = SERVICE_ETHERNET;
}
return FALSE;
}
