Esempio n. 1
0
int main(int argc, char *argv[]) {

    if (argc < 2) {
        cerr << "Usage: " << argv[0] << " <ServerAddr>" << endl;
        return 1;
    }

    memset(gBuf, 0, gBufSize);
    string servAddress = argv[1];
    long long results[2] = {0, 0};

    try {
        for (int i = 0; i < 2; ++i) {
            TCPSocket sock(servAddress, PORT);
            std::chrono::high_resolution_clock::time_point start, end;

            sock.send(CMDLEN(i));
            recv_ans(&sock);

            if (strncmp(gBuf, CMDLEN(2))) {
                printf_s("Wrong answer received. Terminating\n");
                return 1;
            }

            printf_s("Experiment %d\n", i + 1);
            sock.send(CMDLEN(3));

            start = NOW();

            recv_ans(&sock);
            if (!strncmp(gBuf, CMDLEN(4))) {
                end = NOW();
                results[i] = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
                printf_s("Experiment %d took %d ms\n", i + 1, results[i]);
            } else if (!strncmp(gBuf, CMDLEN(5))) {
                printf_s("Experiment was failed\n");
            } else {
                printf_s("Wrong answer received. Terminating\n");
                return 1;
            }
        }


    } catch(SocketException &e) {
        printf_s("Exception: %s\n", e.what());
        return 1;
    }

    return 0;
}
Esempio n. 2
0
static int
usalo_send(SCSI *usalp)
{
	struct usal_cmd	*sp = usalp->scmd;
	int	ret;
	int	i;
	int	amt = sp->cdb_len;
	int flags;
#ifndef	USE_DSLIB
	struct dsreq	ds;
	struct dsreq	*dsp = &ds;

	dsp->ds_iovbuf = 0;
	dsp->ds_iovlen = 0;
#endif

	if (usalp->fd < 0) {
		sp->error = SCG_FATAL;
		return (0);
	}

	flags = DSRQ_SENSE;
	if (sp->flags & SCG_RECV_DATA)
		flags |= DSRQ_READ;
	else if (sp->size > 0)
		flags |= DSRQ_WRITE;

	dsp->ds_flags	= flags;
	dsp->ds_link	= 0;
	dsp->ds_synch	= 0;
	dsp->ds_ret  	= 0;

	DATABUF(dsp) 	= sp->addr;
	DATALEN(dsp)	= sp->size;
	CMDBUF(dsp)	= (void *) &sp->cdb;
	CMDLEN(dsp)	= sp->cdb_len;
	SENSEBUF(dsp)	= (caddr_t)sp->u_sense.cmd_sense;
	SENSELEN(dsp)	= sizeof (sp->u_sense.cmd_sense);
	TIME(dsp)	= (sp->timeout * 1000) + 100;

	errno		= 0;
	sp->ux_errno	= 0;
	sp->sense_count	= 0;

#ifdef	USE_DSLIB
	ret = doscsireq(usalp->fd, dsp);
#else
	ret = usal_sendreq(usalp, sp, dsp);
#endif

	if (RET(dsp) != DSRT_DEVSCSI)
		ret = 0;

	if (RET(dsp)) {
		if (RET(dsp) == DSRT_SHORT) {
			sp->resid = DATALEN(dsp)- DATASENT(dsp);
		} else if (errno) {
			sp->ux_errno = errno;
		} else {
			sp->ux_errno = EIO;
		}

		sp->u_scb.cmd_scb[0] = STATUS(dsp);

		sp->sense_count = SENSESENT(dsp);
		if (sp->sense_count > SCG_MAX_SENSE)
			sp->sense_count = SCG_MAX_SENSE;

	}
	switch (RET(dsp)) {

	default:
		sp->error = SCG_RETRYABLE;	break;

	case 0:			/* OK					*/
	case DSRT_SHORT:	/* not implemented			 */
		sp->error = SCG_NO_ERROR;	break;

	case DSRT_UNIMPL:	/* not implemented			*/
	case DSRT_REVCODE:	/* software obsolete must recompile 	*/
	case DSRT_NOSEL:
		sp->u_scb.cmd_scb[0] = 0;
		sp->error = SCG_FATAL;		break;

	case DSRT_TIMEOUT:
		sp->u_scb.cmd_scb[0] = 0;
		sp->error = SCG_TIMEOUT;	break;
	}
	return (ret);
}