Esempio n. 1
0
 /**
   Duplicate this socket, including its underlying descriptor.
   @return the duplicate StreamSocket on success, NULL+errno on failure.
 */
 virtual YO_NEW_REF StreamSocket* dup() {
   socket_t socket_ = Socket::create(get_domain(), TYPE, get_protocol());
   if (socket_ != static_cast<socket_t>(-1)) {
     return new StreamSocket(get_domain(), get_protocol(), socket_);
   } else {
     return NULL;
   }
 }
Esempio n. 2
0
 virtual YO_NEW_REF TcpSocket* dup() {
     socket_t socket_ = Socket::create(get_domain(), TYPE, PROTOCOL);
     if (socket_ != static_cast<socket_t>(-1)) {
         return new TcpSocket(get_domain(), socket_);
     } else {
         return NULL;
     }
 }
Esempio n. 3
0
int DNS::make_RR_string(char* start, int offset, int number,char*& rr)
{
	char* field_start = start + offset;
	int RR_offset = 0;
	if(number == 0)
		return RR_offset;
	for(int i = 0;i < number; i++)
	{
		unique_ptr<char> domain(new char[256]);
		RR_offset += get_domain(start,field_start + RR_offset,domain.get());
		rr += sprintf(rr,"%s is ",domain.get());

		fixedRR* frr = (fixedRR*) (field_start + RR_offset);
		unsigned short DNS_class;
		unsigned short type;
		int ttl;
		unsigned short RDlen = 0;

		DNS_class = ntohs(frr->dns_class);
		type = ntohs(frr->type);
		ttl = ntohl(frr->TTL);

		RR_offset += sizeof(fixedRR);
		if(frr->dns_class != 1)
		{
		    RDlen = ntohs(*(unsigned short*)(field_start + RR_offset));
		}
		else
		{
		    RDlen = (*(unsigned short*)(field_start + RR_offset));
		}
		
		RR_offset += sizeof(unsigned short);
		if(type == DNS_A)
		{
			string name;
			unsigned long ip = *(unsigned long*)(field_start + RR_offset);
			IN_ADDR in_ip;
			in_ip.s_addr = ip;
			name = inet_ntoa(in_ip);
			rr += sprintf(rr,"%s\n",name.c_str());
			RR_offset += sizeof(unsigned long);
		}
		if(type == DNS_CNAME)
		{
			unique_ptr<char> domain(new char[256]);
            RR_offset += get_domain(start,field_start + RR_offset,domain.get());
			rr += sprintf(rr,"alised to %s\n",domain.get());
		}
		if(type == DNS_PTR)
		{
			unique_ptr<char> domain(new char[256]);
            RR_offset += get_domain(start,field_start + RR_offset,domain.get());
			rr += sprintf(rr,"%s\n",domain.get());
		}	
	}
	return RR_offset;
}
Esempio n. 4
0
static void
do_args(char** argv) {
  /* process the arguments according to the ARGV pattern domain */
  char** ap;
  CIStream argsbuf;
  COStream outbuf;
  const char* remaining;
  boolean ok;

  outbuf = make_buffer_output_stream();
  cos_putch(outbuf, '\n');
  for ( ap = argv ; *ap != NULL ; ap++ ) {
    cos_puts(outbuf, *ap);
    cos_putch(outbuf, '\n');
  }
  argsbuf = convert_output_to_input( outbuf );
  outbuf = make_buffer_output_stream();
  ok = translate ( argsbuf, get_domain(argv_domain_name), outbuf, NULL );
  cis_close(argsbuf);
  argsbuf = convert_output_to_input( outbuf );
  remaining = cis_whole_string(argsbuf);
  while ( isspace(*remaining) )
    remaining++;
  if ( remaining[0] != '\0' ) {
    fprintf(stderr, "Unrecognized arguments:\n%s", remaining);
    ok = FALSE;
  }
  cis_close(argsbuf);
  if ( !ok )
    exit_status = EXS_ARG;
}
Esempio n. 5
0
str* pdt_get_domain(pdt_tree_t *pl, str* sdomain, str *code, int *plen)
{
	pdt_tree_t *it;
	int len;
	str *domain=NULL;

	if(pl==NULL || sdomain==NULL || sdomain->s==NULL || code == NULL
			|| code->s == NULL)
	{
		LM_INFO("bad parameters\n");
		return NULL;
	}

	it = pl;
	while(it!=NULL && str_strcmp(&it->sdomain, sdomain)<0)
		it = it->next;
	
	if(it==NULL || str_strcmp(&it->sdomain, sdomain)>0)
		return NULL;
	
	domain = get_domain(it, code, &len);
	if(plen!=NULL)
			*plen = len;
	return domain;
}
Esempio n. 6
0
int set_global_virq_handler(struct domain *d, uint32_t virq)
{
    struct domain *old;

    if (virq >= NR_VIRQS)
        return -EINVAL;
    if (!virq_is_global(virq))
        return -EINVAL;

    if (global_virq_handlers[virq] == d)
        return 0;

    if (unlikely(!get_domain(d)))
        return -EINVAL;

    spin_lock(&global_virq_handlers_lock);
    old = global_virq_handlers[virq];
    global_virq_handlers[virq] = d;
    spin_unlock(&global_virq_handlers_lock);

    if (old != NULL)
        put_domain(old);

    return 0;
}
Esempio n. 7
0
/* [email protected] */
static char *parse_chpass_clause (const char *clause, const char *username,
				  const char *defdomain, const char *newpass,
				  const char *newpass_crypt)
{
static struct var_data vd[]={
	    {"local_part",	NULL,	sizeof("local_part"),		0},
	    {"domain",		NULL,	sizeof("domain"),		0},
	    {"newpass",		NULL, 	sizeof("newpass"),		0},
	    {"newpass_crypt",	NULL,	sizeof("newpass_crypt"),	0},
	    {NULL,		NULL,	0,				0}};

	if (clause == NULL || *clause == '\0'		||
	    !username || *username == '\0'		||
	    !newpass || *newpass == '\0'		||
	    !newpass_crypt || *newpass_crypt == '\0')	return NULL;

	vd[0].value	= get_localpart (username);
	vd[1].value	= get_domain (username, defdomain);
	vd[2].value	= validate_password (newpass);
	vd[3].value	= validate_password (newpass_crypt);
	
	if (!vd[0].value || !vd[1].value ||
	    !vd[2].value || !vd[3].value)	return NULL;

	return (parse_string (clause, vd));
}
Esempio n. 8
0
static void
query(struct evbuffer *rsps, char *url) 
{
  struct rulelist *node = cfg.rulelist_head;

  char *domain = get_domain(url);

  if (domain == NULL) return;

  while (node != NULL) {
      
    struct hashmap_s *map = node->data;

    struct hashentry_s *it = hashmap_find_head(map, domain);

    while (it != NULL) {
      if (strstr(url, it->data) != NULL 
	  || astermatch(url, it->data) == 0) 

	evbuffer_add_printf(rsps, "%s|%s\n", node->name, it->data);

      it = hashmap_find_next(it, domain);
      
    }
    node = node->next;
  }

}
Esempio n. 9
0
bool Socket::bind(const SocketAddress& _name) {
    const SocketAddress* name = _name.filter(get_domain());
    if (name != NULL) {
        return ::bind(*this, *name, name->len()) != -1;
    } else {
        return false;
    }
}
Esempio n. 10
0
	size_t HashKey(const KeyType& key) const
	{
		net_domain* domain = get_domain(key->sa_family);
		if (domain == NULL)
			return 0;

		return domain->address_module->hash_address(key, false);
	}
Esempio n. 11
0
bool Socket::getsockname(SocketAddress& sockname) const {
    socklen_t socknamelen = sockname.len();
    if (::getsockname(*this, sockname, &socknamelen) != -1) {
        debug_assert_eq(sockname.get_family(), get_domain());
        return true;
    } else {
        return false;
    }
}
Esempio n. 12
0
void lease_update_from_configs(void)
{
  /* changes to the config may change current leases. */
  
  struct dhcp_lease *lease;
  struct dhcp_config *config;
  char *name;
  
  for (lease = leases; lease; lease = lease->next)
    if (lease->flags & (LEASE_TA | LEASE_NA))
      continue;
    else if ((config = find_config(daemon->dhcp_conf, NULL, lease->clid, lease->clid_len, 
				   lease->hwaddr, lease->hwaddr_len, lease->hwaddr_type, NULL)) && 
	     (config->flags & CONFIG_NAME) &&
	     (!(config->flags & CONFIG_ADDR) || config->addr.s_addr == lease->addr.s_addr))
      lease_set_hostname(lease, config->hostname, 1, get_domain(lease->addr), NULL);
    else if ((name = host_from_dns(lease->addr)))
      lease_set_hostname(lease, name, 1, get_domain(lease->addr), NULL); /* updates auth flag only */
}
Esempio n. 13
0
static const char *get_user_jid()
{
	static std::string _jid;
	if (_jid.empty()) {
		std::stringstream ss;
		ss << "normaluser" << "@" << get_domain();
		_jid = ss.str();
	}

	return _jid.c_str();
}
Esempio n. 14
0
bool Socket::connect(const SocketAddress& _peername) {
    const SocketAddress* peername = _peername.filter(get_domain());
    if (peername != NULL) {
        if (::connect(*this, *peername, peername->len()) != -1) {
            return true;
        } else {
            return errno == EISCONN;
        }
    } else {
        return false;
    }
}
Esempio n. 15
0
// 返回 mcu jid
static const char *get_mcu_jid()
{
	static std::string _jid;

	if (_jid.empty()) {
		std::stringstream ss;
		ss << "mse_s_000000000000_mcu_1" << "@" << get_domain();
		_jid = ss.str();
	}

	return _jid.c_str();
}
static int jpsd_tdf_domain_cfg_handle_change(const bn_binding_array *arr,
				uint32 idx, bn_binding *binding, void *data)
{
	int err;
	int i;
	char *rule = NULL;
        const tstring *name = NULL;
        const char *t_domain = NULL;
        domain_t *domain = NULL;
	tstr_array *name_parts = NULL;
        tbool *rechecked_licenses = data;

        UNUSED_ARGUMENT(arr);
        UNUSED_ARGUMENT(idx);

        bail_null(rechecked_licenses);

        err = bn_binding_get_name(binding, &name);
        bail_error(err);

        if (bn_binding_name_pattern_match(ts_str(name), "/nkn/jpsd/tdf/domain/**")) {
                bn_binding_get_name_parts(binding, &name_parts);
                bail_error_null(err, name_parts);

		if (bn_binding_name_parts_pattern_match_va(name_parts, 4, 2, "*", "rule")) {
			t_domain = tstr_array_get_str_quick(name_parts, 4);
			bail_error(err);
			err = bn_binding_get_str(binding, ba_value, bt_string, NULL, &rule);
			if (rule == NULL) goto bail;
			log_debug("Read .../nkn/jpsd/tdf/domain as : \"%s\"", t_domain);
			domain = get_domain(t_domain);
			for (i = 0; i < MAX_DOMAIN_RULE; i++) {
				if (g_domain_rule[i].active &&
					(strcmp(g_domain_rule[i].name, rule) == 0)) {
					memcpy(&domain->rule, &g_domain_rule[i],
								sizeof(domain->rule));
					break;
				}
			}
			safe_free(rule);
			insert_domain(domain);
		} else {
			goto bail;
		}


        }

bail:
        tstr_array_free(&name_parts);
        return err;
}
Esempio n. 17
0
int main() {
    // Model, Domain and Boundary
    const auto flow = std::make_unique<Flow>("Couette3D");
    const auto lbmodel = flow->get_lbmodel();
    const auto domain = flow->get_domain();
    const auto boundary = flow->get_boundary();

    // Define problem and its data
    const auto problem = std::make_unique<PLBPD>(lbmodel, domain, boundary);
    auto simdata =
        SimData(domain->get_dimensions(), lbmodel->get_num_directions());

    // Solve problem
    problem->initialize(simdata);
    simdata.write_state("init_state.h5");
    problem->march_in_time(flow->get_num_timesteps(), simdata);
    simdata.write_state("final_state.h5");
    problem->print_times();
}
Esempio n. 18
0
/* [email protected] */
static char *parse_select_clause (const char *clause, const char *username,
				  const char *defdomain)
{
static struct var_data vd[]={
	    {"local_part",	NULL,	sizeof("local_part"),	0},
	    {"domain",		NULL,	sizeof("domain"),	0},
	    {NULL,		NULL,	0,			0}};

	if (clause == NULL || *clause == '\0' ||
	    !username || *username == '\0')
		return NULL;
	
	vd[0].value	= get_localpart (username);
	vd[1].value	= get_domain (username, defdomain);
	if (!vd[0].value || !vd[1].value)
		return NULL;
	
	return (parse_string (clause, vd));
}
static int jpsd_tdf_domain_delete_cfg_handle_change(const bn_binding_array *arr,
				uint32 idx, bn_binding *binding, void *data)
{
	int err;
        const tstring *name = NULL;
        const char *t_domain = NULL;
        domain_t *domain = NULL;
	tstr_array *name_parts = NULL;
        tbool *rechecked_licenses = data;

        UNUSED_ARGUMENT(arr);
        UNUSED_ARGUMENT(idx);

        bail_null(rechecked_licenses);

        err = bn_binding_get_name(binding, &name);
        bail_error(err);

        if (bn_binding_name_pattern_match(ts_str(name), "/nkn/jpsd/tdf/domain/*")) {
		int incarn;
                bn_binding_get_name_parts(binding, &name_parts);
                bail_error_null(err, name_parts);

                t_domain = tstr_array_get_str_quick(name_parts, 4);
                bail_error(err);
                domain = get_domain(t_domain);
		if (domain == NULL) goto bail;
		delete_domain(domain);
		pthread_rwlock_wrlock(&domain->rwlock);
		domain->name[0] = '\0';
		domain->active = 0;
		domain->incarn++;
		memset(&domain->rule, 0, sizeof(domain_rule_t));
		pthread_rwlock_unlock(&domain->rwlock);
        } else {
                goto bail;
        }

bail:
        tstr_array_free(&name_parts);
        return err;
}
Esempio n. 20
0
struct domain *find_domain_by_id(domid_t dom)
{
    struct domain *d;

    read_lock(&domlist_lock);
    d = domain_hash[DOMAIN_HASH(dom)];
    while ( d != NULL )
    {
        if ( d->domain_id == dom )
        {
            if ( unlikely(!get_domain(d)) )
                d = NULL;
            break;
        }
        d = d->next_in_hashbucket;
    }
    read_unlock(&domlist_lock);

    return d;
}
Esempio n. 21
0
int NEO_cache_domain(TRbDict * dict, char *str, URLNODE_T * urlNode)
{
    int nodeLen;
    unsigned signs[4];
    char domain[MAX_URL_LEN];
    void *tmp;
    DOMAINNODE_T *domainNode;

    if (get_domain(str, domain, MAX_URL_LEN) == -1)
        return -1;

    assert(MD5(domain, strlen(domain), (unsigned char *) signs));

    if (rb_dict_search(dict, signs, (void **) &domainNode) == 0)
    {
        // found!!!
        assert(domainNode && domainNode->urlDict);
        printf("src : %llu %s\n", *(KEY_T *) signs, domain);
    } else
    {
        // not found!!!
        tmp = (void *) calloc(sizeof(KEY_T), +sizeof(DOMAINNODE_T));
        assert(tmp);

        memcpy(tmp, signs, sizeof(KEY_T));

        // insert a new domain 
        rb_dict_insert(dict, tmp, tmp + sizeof(KEY_T), 0);

        // creat urlcache about this domain
        domainNode = (DOMAINNODE_T *) (tmp + sizeof(KEY_T));
        snprintf(domainNode->domain, MAX_DOMAIN_LEN, "%s", domain);

        __cache_init(domainNode);
    }

    url_trim(str);
    __cache_url(domainNode->urlDict, NULL, str, urlNode);

    return 0;
}
Esempio n. 22
0
ssize_t
DatagramSocket::sendmsg(
  const iovec* iov,
  int iovlen,
  const MessageFlags& flags,
  const SocketAddress& peername
) {
  msghdr msghdr_;
  memset(&msghdr_, 0, sizeof(msghdr_));
  msghdr_.msg_iov = const_cast<iovec*>(iov);
  msghdr_.msg_iovlen = iovlen;
  const SocketAddress* peername_ = peername.filter(get_domain());
  if (peername_ != NULL) {
    const sockaddr* peername_sockaddr = *peername_;
    msghdr_.msg_name = const_cast<sockaddr*>(peername_sockaddr);
    msghdr_.msg_namelen = peername_->len();
  } else {
    return -1;
  }
  return ::sendmsg(*this, &msghdr_, flags);
}
Esempio n. 23
0
ssize_t
DatagramSocket::sendto(
  const void* buf,
  size_t buflen,
  const MessageFlags& flags,
  const SocketAddress& peername
) {
  const SocketAddress* peername_ = peername.filter(get_domain());
  if (peername_ != NULL) {
    return ::sendto(
             *this,
             static_cast<const char*>(buf),
             buflen,
             flags,
             *peername_,
             peername_->len()
           );
  } else {
    return -1;
  }
}
Esempio n. 24
0
static void
gen_conditions_for_pow_cst_base (tree base, tree expn,
                                 vec<gimple> conds,
                                 unsigned *nconds)
{
  inp_domain exp_domain;
  /* Validate the range of the base constant to make
     sure it is consistent with check_pow.  */
  REAL_VALUE_TYPE mv;
  REAL_VALUE_TYPE bcv = TREE_REAL_CST (base);
  gcc_assert (!REAL_VALUES_EQUAL (bcv, dconst1)
              && !REAL_VALUES_LESS (bcv, dconst1));
  real_from_integer (&mv, TYPE_MODE (TREE_TYPE (base)), 256, UNSIGNED);
  gcc_assert (!REAL_VALUES_LESS (mv, bcv));

  exp_domain = get_domain (0, false, false,
                           127, true, false);

  gen_conditions_for_domain (expn, exp_domain,
                             conds, nconds);
}
Esempio n. 25
0
unsigned NEO_cache_check(TRbDict * dict, char *str)
{
    unsigned signs[4];
    char domain[MAX_URL_LEN];
    DOMAINNODE_T *tmp = NULL;

    if (get_domain(str, domain, MAX_URL_LEN) == -1)
        return (unsigned) -1;

    assert(MD5(domain, strlen(domain), (unsigned char *) signs));

    if (rb_dict_search(dict, signs, (void **) &tmp) != 0)
    {
        return 0;
    } else
    {
        assert(tmp);
        return rb_dict_count(((DOMAINNODE_T *) tmp)->urlDict);
    }

    return 0;
}
Esempio n. 26
0
struct domain *get_domain_by_id(domid_t dom)
{
    struct domain *d;

    rcu_read_lock(&domlist_read_lock);

    for ( d = rcu_dereference(domain_hash[DOMAIN_HASH(dom)]);
          d != NULL;
          d = rcu_dereference(d->next_in_hashbucket) )
    {
        if ( d->domain_id == dom )
        {
            if ( unlikely(!get_domain(d)) )
                d = NULL;
            break;
        }
    }

    rcu_read_unlock(&domlist_read_lock);

    return d;
}
Esempio n. 27
0
struct nl_client *
vr_get_nl_client(unsigned int proto)
{
    int ret;
    unsigned int sock_proto = proto;
    struct nl_client *cl;

    cl = nl_register_client();
    if (!cl)
        return NULL;

    parse_ini_file();

    if (proto == VR_NETLINK_PROTO_DEFAULT)
        sock_proto = get_protocol();

    ret = nl_socket(cl, get_domain(), get_type(), sock_proto);
    if (ret <= 0)
        goto fail;

    ret = nl_connect(cl, get_ip(), get_port());
    if (ret < 0)
        goto fail;

    if ((proto == VR_NETLINK_PROTO_DEFAULT) &&
            (vrouter_get_family_id(cl) <= 0))
        goto fail;

    return cl;

fail:
    if (cl)
        nl_free_client(cl);

    return NULL;
}
static long __evtchn_close(struct domain *d1, int port1)
{
    struct domain *d2 = NULL;
    struct vcpu   *v;
    struct evtchn *chn1, *chn2;
    int            port2;
    long           rc = 0;

 again:
    spin_lock(&d1->evtchn_lock);

    if ( !port_is_valid(d1, port1) )
    {
        rc = -EINVAL;
        goto out;
    }

    chn1 = evtchn_from_port(d1, port1);

    /* Guest cannot close a Xen-attached event channel. */
    if ( unlikely(chn1->consumer_is_xen) )
    {
        rc = -EINVAL;
        goto out;
    }

    switch ( chn1->state )
    {
    case ECS_FREE:
    case ECS_RESERVED:
        rc = -EINVAL;
        goto out;

    case ECS_UNBOUND:
        break;

    case ECS_PIRQ:
        pirq_guest_unbind(d1, chn1->u.pirq);
        d1->pirq_to_evtchn[chn1->u.pirq] = 0;
        break;

    case ECS_VIRQ:
        for_each_vcpu ( d1, v )
        {
            if ( v->virq_to_evtchn[chn1->u.virq] != port1 )
                continue;
            v->virq_to_evtchn[chn1->u.virq] = 0;
            spin_barrier(&v->virq_lock);
        }
        break;

    case ECS_IPI:
        break;

    case ECS_INTERDOMAIN:
        if ( d2 == NULL )
        {
            d2 = chn1->u.interdomain.remote_dom;

            /* If we unlock d1 then we could lose d2. Must get a reference. */
            if ( unlikely(!get_domain(d2)) )
                BUG();

            if ( d1 < d2 )
            {
                spin_lock(&d2->evtchn_lock);
            }
            else if ( d1 != d2 )
            {
                spin_unlock(&d1->evtchn_lock);
                spin_lock(&d2->evtchn_lock);
                goto again;
            }
        }
        else if ( d2 != chn1->u.interdomain.remote_dom )
        {
            /*
             * We can only get here if the port was closed and re-bound after
             * unlocking d1 but before locking d2 above. We could retry but
             * it is easier to return the same error as if we had seen the
             * port in ECS_CLOSED. It must have passed through that state for
             * us to end up here, so it's a valid error to return.
             */
            rc = -EINVAL;
            goto out;
        }

        port2 = chn1->u.interdomain.remote_port;
        BUG_ON(!port_is_valid(d2, port2));

        chn2 = evtchn_from_port(d2, port2);
        BUG_ON(chn2->state != ECS_INTERDOMAIN);
        BUG_ON(chn2->u.interdomain.remote_dom != d1);

        chn2->state = ECS_UNBOUND;
        chn2->u.unbound.remote_domid = d1->domain_id;
        break;

    default:
        BUG();
    }

    /* Clear pending event to avoid unexpected behavior on re-bind. */
    clear_bit(port1, shared_info_addr(d1, evtchn_pending));

    /* Reset binding to vcpu0 when the channel is freed. */
    chn1->state          = ECS_FREE;
    chn1->notify_vcpu_id = 0;

    xsm_evtchn_close_post(chn1);

 out:
    if ( d2 != NULL )
    {
        if ( d1 != d2 )
            spin_unlock(&d2->evtchn_lock);
        put_domain(d2);
    }

    spin_unlock(&d1->evtchn_lock);

    return rc;
}
Esempio n. 29
0
status_t
icmp6_receive_data(net_buffer *buffer)
{
	TRACE(("ICMPv6 received some data, buffer length %" B_PRIu32 "\n",
		buffer->size));

	net_domain* domain = get_domain(buffer);
	if (domain == NULL)
		return B_ERROR;

	NetBufferHeaderReader<icmp6_hdr> bufferHeader(buffer);
	if (bufferHeader.Status() < B_OK)
		return bufferHeader.Status();

	icmp6_hdr &header = bufferHeader.Data();

	TRACE(("  got type %u, code %u, checksum 0x%x\n", header.icmp6_type,
			header.icmp6_code, header.icmp6_cksum));

	net_address_module_info* addressModule = domain->address_module;

	// compute and check the checksum
 	if (Checksum::PseudoHeader(addressModule, gBufferModule, buffer,
 			IPPROTO_ICMPV6) != 0)
 		return B_BAD_DATA;

	switch (header.icmp6_type) {
		case ICMP6_ECHO_REPLY:
			break;

		case ICMP6_ECHO_REQUEST:
		{
			if (buffer->interface_address != NULL) {
				// We only reply to echo requests of our local interface; we
				// don't reply to broadcast requests
				if (!domain->address_module->equal_addresses(
						buffer->interface_address->local, buffer->destination))
					break;
			}

			net_buffer *reply = gBufferModule->duplicate(buffer);
			if (reply == NULL)
				return B_NO_MEMORY;

			gBufferModule->swap_addresses(reply);

			// There already is an ICMP header, and we'll reuse it
			NetBufferHeaderReader<icmp6_hdr> header(reply);

			header->icmp6_type = ICMP6_ECHO_REPLY;
			header->icmp6_code = 0;
			header->icmp6_cksum = 0;

			header.Sync();

			*ICMP6ChecksumField(reply) = Checksum::PseudoHeader(addressModule,
				gBufferModule, buffer, IPPROTO_ICMPV6);

			status_t status = domain->module->send_data(NULL, reply);
			if (status < B_OK) {
				gBufferModule->free(reply);
				return status;
			}
		}

		default:
			// unrecognized messages go to neighbor discovery protocol handler
			return sIPv6NDPModule->receive_data(buffer);
	}

	gBufferModule->free(buffer);
	return B_OK;
}
Esempio n. 30
0
static void
handle_request(void *ctx) {
  conn_t *conn = ctx;
  struct evbuffer *rsps = evbuffer_new();
  struct state *s = conn->state;

  if (strcmp(conn->method, "GET") == 0) {

    if (strcmp(conn->url, "/getproxies") == 0) 
      get_proxies(rsps);

    else if (strcmp(conn->url, "/getlists") == 0) 
      get_lists(rsps);

    else if (strncmp(conn->url, "/query?", 7) == 0)
      query(rsps, evhttp_decode_uri(conn->url + 7));

    else if (strcmp(conn->url, "/getlog") == 0) 
      get_log(rsps);

    else if (strcmp(conn->url, "/gettrylist") == 0) 
      get_trylist(rsps);

    else if (strcmp(conn->url, "/getversion") == 0) 
      evbuffer_add_printf(rsps, VERSION);

  }
  else if (strcmp(conn->method, "POST") == 0) {

    struct evkeyvalq kv;
    struct evhttp_uri *uri = evhttp_uri_parse_with_flags(conn->url, 0);

    evhttp_parse_query_str(evhttp_uri_get_query(uri), &kv);

    char *cont;
    if (s->length) 
      cont = s->body;

    const char *path = evhttp_uri_get_path(uri);

    if (strcmp(path, "/addrule") == 0 || strcmp(path, "/rmrule") == 0) {

      struct evkeyvalq kvc;
      evhttp_parse_query_str(cont, &kvc);

      char *list = evhttp_decode_uri(evhttp_find_header(&kvc, "list"));
      char *rule = evhttp_decode_uri(evhttp_find_header(&kvc, "rule"));

      if (get_domain(rule) == NULL) 
	evbuffer_add_printf(rsps, "Invalid rule.");
      
      else {
	if (strcmp(path, "/addrule") == 0)
	  update_rule(list, rule);
      
	else 
	  remove_rule(list, rule);

	evbuffer_add_printf(rsps, "OK");
      }
      free(list);
      free(rule);

      free(cont);
    }

    else if (strcmp(path, "/flush") == 0) {
      flush_list();
      evbuffer_add_printf(rsps, "OK");
    }
    else if (strcmp(path, "/rmlog") == 0) {
      rm_log(rsps);
    }
    else if (strcmp(path, "/purgetrylist") == 0) {
      purgetrylist(rsps);
    }

    evhttp_uri_free(uri);
  }
  ret(conn->be_client, rsps);
  evbuffer_free(rsps);

}