/*
 * We end up here due to a osegw_receive, osegw_receive_w_tmo or
 * osegw_init_async_receive. While we are waiting for a signal,
 * we must be able to handle "pings" and osegw_cancel_async_receive
 * from the client.
 */
int OseGW_PLT_ReceiveRequest_cbk(int skt, int len, char *payload,
                                 struct ClientInfo *cinfo)
{
	struct OseGW_ReceiveRequest *req;
        struct OseGW_TransportHdr thdr;
        union LINX_SIGNAL *sig;
        LINX_SIGSELECT *sigsel;
        int nfds, status, size, linx_skt, sigsel_len;
        fd_set rfds;
        struct timeval tv0, tv, *tvp;
        unsigned int tmo;
        void *buf;

        linx_skt = linx_get_descriptor(cinfo->linx);
	req = (struct OseGW_ReceiveRequest *)payload;
        sigsel_len = ntohl(req->sigsel_len);
        buf = NULL;

        /* 0. This may be a osegw_cancel_async_receive... */
        if (sigsel_len == 0) {
                sig = NULL;
                size = 0;
                goto out;
        }

        /* 1. Setup signal filter that should be used while polling... */
        sigsel = copy_sigselect(req);
        if (sigsel == NULL)
                goto e_exit;
        if (set_sigselect(linx_skt, sigsel) == -1)
                goto e_exit;

        /* 2. Setup time-out... */
	tmo = ntohl(req->timeout);
        if (tmo != (unsigned int)~0) {
                tvp = msec_to_timeval(tmo, &tv);
                if (gettimeofday(&tv0, NULL) == -1)
                        goto e_exit;
        } else
                tvp = NULL; /* Infinite */

  again:

        /* 3. Setup descriptors... */
        FD_ZERO(&rfds);
        FD_SET(linx_skt, &rfds); /* LINX socket */
        FD_SET(skt, &rfds);      /* TCP socket */
        nfds = linx_skt > skt ? linx_skt : skt;

        /* 4. Wait for a signal, ping or osegw_cancel_async_receive */
        status = select(nfds + 1, &rfds, NULL, NULL, tvp);
        if (status == -1)
                goto e_exit;

        if (status == 0) {
                /* osegw_receive_w_tmo has timed out */
                sig = NULL;
                size = 0;
                goto out;
        }

        if (FD_ISSET(linx_skt, &rfds)) {
                /* A signal that matches the signal filter is available */
                status = linx_receive(cinfo->linx, &sig, sigsel);
                if (status == -1)
                        goto e_exit;
                size = linx_sigsize(cinfo->linx, &sig) - sizeof(SIGSELECT);
                goto out;
        }

        if (FD_ISSET(cinfo->sd, &rfds)) {
                /* Get command */
                buf = get_command(skt, &thdr);
                if (buf == NULL)
                        goto e_exit;

                switch (thdr.payload_type) {
                case OseGW_PLT_InterfaceRequest:
                        status = OseGW_PLT_InterfaceRequest_cbk(skt, thdr.payload_len, buf, cinfo);
                        if (status == -1)
                                goto e_exit;
                        /* Compensate for the time spent in select */
                        if (tvp != NULL)
                                recalc_tmo(tmo, &tv0, &tv);
                        goto again;
                        break;
                case OseGW_PLT_ReceiveRequest:
                        req = (struct OseGW_ReceiveRequest *)buf;
                        sigsel_len = ntohl(req->sigsel_len);
                        if (sigsel_len != 0)
                                goto e_exit; /* Only cancel async receive is allowed */
                        sig = NULL;
                        size = 0;
                        goto out;
                        break;
                default:
                        syslog(LOG_INFO, "Gateway protocol violation detected, "
                               "got type %d while in a receive", thdr.payload_type);
                        goto e_exit;
                        break;
                }
        }
  out:
        free(buf);
        free(sigsel);
        return OseGW_PLT_ReceiveReply_cbk(skt, size, (char *)sig, cinfo);

  e_exit:
        free(buf);
        free(sigsel);
        return -1;
}
예제 #2
0
static void test_without_linxlib(LINX_SPID client, LINX * linx)
{
	int len, sig_len;
	struct sockaddr_linx to;
	socklen_t socklen;
	int sd = linx_get_descriptor(linx);
	size_t msg_size = 65536;
	union LINX_SIGNAL *sig = malloc(msg_size);

	if (sig == NULL) {
		ERR("Failed to allocate memory");
		exit(1);
	}
	socklen = sizeof(struct sockaddr_linx);
	to.family = AF_LINX;
	to.spid = LINX_ILLEGAL_SPID;

	for (;;) {
		len = sig_len = recvfrom(sd,
					 sig,
					 msg_size,
					 0, (struct sockaddr *)(void *)&to,
					 &socklen);

		if (unlikely(len <= 0)) {
			ERR("Failed to receive a signal(%d, %d)\n", len, errno);
			continue;
		}

		if (unlikely(to.spid != client)) {
			WARN("Ignoring signal from spid %#x since it is"
			     " not %#x", to.spid, client);
			continue;
		}

		switch (sig->sigNo) {
		case ECHO_SIG:
			TRACE(1, "Sending echo");

			len = sendto(sd, sig, len,
				     0, (struct sockaddr *)(void *)&to,
				     socklen);
			if (unlikely(sig_len != len)) {
				ERR("sendto returned: %d when asked "
				    "for: %d", len, sig_len);
			}
			if (unlikely(len <= 0)) {
				ERR("Failed to send the echo signal "
				    "(%d, %s)\n", len, strerror(errno));
			}
			break;

		case TERMINATE_REQ:
			TRACE(1, "Terminating");
			free(sig);
			linx_close(linx);
			return;

		case ATTACH_TEST_REQ:
			len = sendto(sd, sig, len,
				     0, (struct sockaddr *)(void *)&to,
				     socklen);
			if (unlikely(sig_len != len)) {
				ERR("sendto returned: %d when asked "
				    "for: %d", len, sig_len);
			}
			if (unlikely(len <= 0)) {
				ERR("Failed to send the echo signal "
				    "(%d, %s)\n", len, strerror(errno));
			}
			linx_close(linx);
			return;

		case BURST_REQ:
			{
				uint32_t sigCnt = ntohl(sig->burstReq.n);
				uint32_t reply_size =
				    ntohl(sig->burstReq.reply_size);

				LINX_SIGSELECT reply_sigNo =
				    ntohl(sig->burstReq.reply_sigNo);

				/* Allocate all signals before sending then to
				 * make the send loop as tight as possible */
				sig->burstSig.sigNo = reply_sigNo;
				while (sigCnt--) {
					len = sendto(sd, sig, reply_size,
						     0,
						     (struct sockaddr *)(void *)&to,
						     socklen);
					if (unlikely
					    (reply_size != (uint32_t) len)) {
						ERR("sendto returned: %d when "
						    "asked for: %d", len,
						    reply_size);
					}
					if (unlikely(len <= 0)) {
						ERR("Failed to send the echo "
						    "signal (%d, %s)\n",
						    len, strerror(errno));
					}
				}
				break;
			}

		default:
			WARN("Ignoring unknown signal %ud", sig->sigNo);
		}
	}
	free(sig);
}