예제 #1
0
파일: FCGXStream.cpp 프로젝트: aptana/Jaxer
void
FCGXStream::RecvString(nsACString &s)
{
    PRUint16 len = RecvUint16();
    while (len > 0) {
        PRUint32 n = 0;
        const char *p = RecvBytes(n, len);
        if (!p)
            return;
        s.Append(p, n);
        len -= n;
    }
}
예제 #2
0
파일: FCGXStream.cpp 프로젝트: aptana/Jaxer
NS_IMETHODIMP
FCGXStream::ResumeDocumentReceive()
{
    // Make sure all post data has been consumed.
    PRUint32 len = 0;
    while (0 != RecvBytes(len)) { } ; // empty loop body
    if (mFD == INVALID_SOCKET)
        goto errorAbort;

    // Begin next block.  What we expect depends on whether EndRequest was seen
    // prior to receiving the first PostData block.  If it was, then the next
    // block must be another EndRequest; otherwise, the next block may be either
    // Document or EndRequest.  Regardless, the set-aside document text will be
    // read first (pretend the current block is Document so that will happen).
    mRecvCurBlockType = bt_Document;

    // Let the input pump start pumping again.
    PR_ExitMonitor(mLock);
    return NS_OK;

errorAbort:
    PR_ExitMonitor(mLock);
    return NS_ERROR_ABORT;
}
예제 #3
0
int SeisPipe2D(DsuTask *zz)
{

  int nt,nx,nz,nw,ntpad,ntfft;
  int it,ix,iz,izz,iw,iw0,iw1,iw2,iw3,iwmin,iwmax;
  int nfreqs,verbose;

  float dt,dx,dy,dz,dw;
  float freqs[4],fw,w,scale,fftscl;
  float *p, **v, *wdxov,*sx;

  complex *cpx;
  float **qx;

  void *TabInfo;
  eTable *et;


  char 	msg[80];

  int   info, ToTid, MasterTid;
  int   sz, pz, pei;

  int	SeisIntPars[20];
  float	SeisFloPars[20];


/* Receive process control information */
  MsgLog(zz, "Receiving Control info  ... " );

  MasterTid = RecvInt(SeisIntPars, 2, -1, MsgCntl); 
  pei = SeisIntPars[0];
  ToTid = SeisIntPars[1];

  MsgLog(zz, " Ready  \n");
  
/*  Receive: 	efile and other pars ...  */

  MsgLog(zz, "Receiving parameters ..." );

  TabInfo = RecvBytes(-1, MsgTable);
  RecvFI(SeisFloPars, 10, SeisIntPars, 10, -1, -1);

  MsgLog(zz, " Ready  \n" );

/* get integer parameters */

  nt = SeisIntPars[0];
  nx = SeisIntPars[1];
  nz = SeisIntPars[2];
  ntpad = SeisIntPars[3];
  verbose = SeisIntPars[4];
  sz = SeisIntPars[5];
  pz = SeisIntPars[6];

  	
/* get Floating point parameters */
  dt = SeisFloPars[0];
  dx = SeisFloPars[1];
  dz = SeisFloPars[2];

  freqs[0] = SeisFloPars[3];
  freqs[1] = SeisFloPars[4];
  freqs[2] = SeisFloPars[5];
  freqs[3] = SeisFloPars[6];

  sz = nz / pz;
  if (pei == (pz - 1)) sz += nz % pz;

  sprintf(msg, "Receiving Velocity info (pei = %d, sz = %d) ... ", pei, sz);
  MsgLog(zz,msg);
  
  v   = alloc2float(nx, sz);

  for (iz=0; iz<sz; ++iz)
    RecvFloat(v[iz], nx, -1, MsgVel);

  MsgLog(zz, " Ready  \n" );

/* determine frequency w sampling */
  ntfft = npfar(nt+ntpad);
  nw = ntfft/2+1;
  dw = 2.0*PI/(ntfft*dt);
  iwmin = MAX(0,MIN(nw-1,NINT(2.0*PI*freqs[0]/dw)));
  iwmax = MAX(0,MIN(nw-1,NINT(2.0*PI*freqs[3]/dw)));
	
/* read extrapolator table */
  et = ezread(TabInfo);
  /* pret(zz -> fp_log, et); */
	
/* allocate workspace */

  MsgLog(zz, "Allocating space ... ");

  qx = alloc2float(nx,sz);
  sx = alloc1float(nx);
  wdxov = alloc1float(nx);
  cpx = alloc1complex(nx);
 
  MsgLog(zz, " Ready \n");

  sprintf(msg, "Process (%d) starting loop on depth steps(%d,%d)\n", 
			pei, pei*(nz/pz), pei*(nz/pz) + sz);
  MsgLog(zz, msg);

  /*  Cleanup qx */

  for (iz=0; iz<sz; ++iz)
          for (ix=0; ix<nx; ++ix)
                  qx[iz][ix] = 0.0;

  /* loop over frequencies w */
  for (iw=iwmin,w=iwmin*dw; iw<iwmax; ++iw,w+=dw) {

    if (verbose && !(iw%1)) {
      sprintf(msg, "\t%d/%d\n",iw,iwmax);
      MsgLog(zz, msg);
    }

    /* load wavefield */
    RecvCplx(cpx, nx, -1, MsgSlice);

    /* loop over depth steps nz */

    for (iz=0; iz<sz; ++iz) {

        /* compute 2.0*dx/v(x) and zero migrated data */
        for (ix=0; ix<nx; ix++)
                  sx[ix] = 2.0*dx/v[iz][ix];

        /* make w*dx/v(x) */
        for (ix=0; ix<nx; ++ix)
                wdxov[ix] = w*sx[ix];

        /* extrapolate wavefield */
        etextrap(et,nx,wdxov,cpx);

        /* accumulate migrated data */
        for (ix=0; ix<nx; ++ix)
                qx[iz][ix] += cpx[ix].r;
    }
    /* Send down the wavefield */
    if ( pei != (pz -1))
            SendCplx(cpx, nx, ToTid, MsgSlice);

  } /* End of loop for iw */

  for (iz=0; iz<sz; iz++) {

    izz = pei*(nz/pz) + iz;
    if (verbose) {
      sprintf(msg, "Sending values for iz = %d\n",izz);
      MsgLog(zz, msg);
    }

    SendFI(qx[iz], nx, &izz, 1, MasterTid, MsgDepth);
  }

  sprintf(msg, "End of processing  for (%d)\n",pei);
  MsgLog(zz, msg);

  /* free workspace */
  free1float(sx);
  free1float(wdxov);
  free2float(v);
  free2float(qx);
  free1complex(cpx);

  pvm_exit();
  return(0);
}
예제 #4
0
// The code below illustrates how to use sensocol, but is device/platform dependent.
// Please see the inline comments for details
int main(int argc, char *argv[])
{
  
    int sock;                        /* Socket descriptor */
    struct sockaddr_in servAddr; /* Server address */
    unsigned short servPort;     /* Server port */
    char *servIP;                    /* Server IP address (dotted quad) */
    char sendBuffer[SNDBUFSIZE];                /* Buffer to hold data sent across TCP */
    unsigned char recvBuffer[RCVBUFSIZE];     /* Buffer to hold data received */
    char schemaBuffer[SCHBUFSIZE];          /* Buffer to hold schema */
    unsigned int sendBufferLength, schemaLength;      /* Length of string to echo */
    int i;
    sensocol_packet_t packet;       /* Sensocol packet */
    md5_hash_t schema_md5;
    unsigned char access_token[16] = {0xbd, 0x3b, 0xf0, 0x4f, 0xe3, 0x99, 0xfc, 0x90, 0x14, 0xfa, 0x0d, 0xdb, 0x03, 0xf2, 0x75, 0x9b}; /* Used to authenticate to server */
    unsigned long access_key = 2134507778; /* Used to authenticate with server */
    ///////////////////////
    //  The AES 128 encryption key for this device
    unsigned char key[16]; //= {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};

    for (i = 0; i < sizeof(key);i++) key[i] = i;
    if ((argc < 3) || (argc > 4))    /* Test for correct number of arguments */
    {
       fprintf(stderr, "Usage: %s <Server IP> <Server Port> \n",
               argv[0]);
       exit(1);
    }

    servIP = argv[1];             /* First arg: server IP address (dotted quad) */

    servPort = atoi(argv[2]); /* Use given port, if any */

    ///////////////////////////////
    // Create the sensor packet
    // /////////////////////
    sensocol_packet_init(&packet, "test_sensor", strlen("test_sensor"));

    sensocol_packet_add_long(&packet, strlen("testLong"), "testLong", 1);
    sensocol_packet_add_long_long(&packet, strlen("testLong64"), "testLong64", 123456789000);
    sensocol_packet_add_string(&packet,strlen("testString"), "testString", "testing", strlen("testing"));
    sensocol_packet_add_bytes(&packet, strlen("testBytes"), "testBytes", "foo foo", strlen("foo foo"));
    sensocol_packet_add_float(&packet, strlen("afloat"), "afloat", 123.34);
    sensocol_packet_add_double(&packet, strlen("testDouble"), "testDouble", 123.321);
    // Create the schema
    // NOTE: The schema in an embedded system can be HARD CODED as a constant.  It need not be generated dynamically.
    schemaLength = sensocol_schema_from_packet(&packet, schemaBuffer);

    // Get schema MD5.  This too can/should be hard-coded
    md5(schema_md5, schemaBuffer, schemaLength * 8);

    // For test/debugging purposes dump the MD5 & Schema
    dump(stdout, schema_md5, 16);
    printf("Schema is: %s\n", schemaBuffer);

    // For test/debugging purposes, dump the encoded data
    sensocol_print(&packet);

    // Generate the actual packet to send across the wire
    //sendBufferLength = sensocol_generate_aes128_post_packet(&packet, access_key, access_token, schema_md5, sendBuffer, key);

    sendBufferLength = sensocol_generate_post_packet(&packet, access_key, access_token, schema_md5, sendBuffer);
    printf("Sending Over Wire:\n");
    dump(stdout, sendBuffer, sendBufferLength);

    /* Create a reliable, stream socket using TCP */
    if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        DieWithError("socket() failed");

    /* Construct the server address structure */
    memset(&servAddr, 0, sizeof(servAddr));     /* Zero out structure */
    servAddr.sin_family      = AF_INET;             /* Internet address family */
    servAddr.sin_addr.s_addr = inet_addr(servIP);   /* Server IP address */
    servAddr.sin_port        = htons(servPort); /* Server port */

    /* Establish the connection to the echo server */
    if (connect(sock, (struct sockaddr *) &servAddr, sizeof(servAddr)) < 0)
        DieWithError("connect() failed");


    /* Send the string to the server */
    if (send(sock, sendBuffer, sendBufferLength, 0) != sendBufferLength)
        DieWithError("send() sent a different number of bytes than expected");

    RecvBytes(sock, recvBuffer, 1);
    /* Receive the same string back from the server */

    switch(recvBuffer[0]){
      case SENSOCOL_RESPONSE_OK:
        printf("Data Sent Successfully\n");
        break;
      case SENSOCOL_REQUEST_SCHEMA:
        printf("Schema Request\n");
        sendBufferLength = sensocol_schema_generate_response(&packet, schemaBuffer, schemaLength, sendBuffer);
        if (send(sock, sendBuffer, sendBufferLength, 0) != sendBufferLength)
          DieWithError("send() sent a different number of bytes than expected");
        RecvBytes(sock, recvBuffer, 1);

        switch(recvBuffer[0]){
          case SENSOCOL_RESPONSE_OK:
            printf("Data Sent Successfully\n");
            break;
          case SENSOCOL_RESPONSE_SCHEMA_ERROR:
            DieWithError("Error with Schema\n");
            break;
          case SENSOCOL_RESPONSE_PARSE_ERROR:
            DieWithError("Error parsing packet\n");
            break;
        }
        break;
      case SENSOCOL_RESPONSE_AUTH_ERROR:
        printf("Invalid User Key or Token\n");
        break;
      default:
        printf("Unknown Response");
        break;
    }
    
    close(sock);
    exit(0);
}
예제 #5
0
파일: FCGXStream.cpp 프로젝트: aptana/Jaxer
NS_IMETHODIMP
FCGXStream::RequestPostData()
{
    // Grab the lock and don't release it until document receive is resumed.
    // This will block Mozilla's input pump while we're fetching the post data
    // on the connection.
    PR_EnterMonitor(mLock);

    if (mRecvCurBlockType != bt_Document && mRecvCurBlockType != bt_EndRequest) {
        LogFatal("Stream not positioned correctly for requesting post data.");
        CloseConnection(true);
        return NS_ERROR_ABORT;
    }

    // Send a RequirePostData block to the web server.
    SendBlockType(bt_RequirePostData);
    Flush(false);
    if (mFD == INVALID_SOCKET)
        return NS_ERROR_ABORT;

    // If we're in the middle of receiving the document, save what's left of the
    // current block and continue receiving and saving document text until a
    // PostData block finally arrives.
    if (mRecvCurBlockType == bt_Document) {
        PRUint32 len = 0;
        while (const char *p = RecvBytes(len)) {
            DocText *dt = (DocText *)PR_Malloc(sizeof(DocText) + len - sizeof(void*));
            dt->mNext = mDocText;
            dt->mLen = len;
            memcpy(dt->mText, p, len);
            mDocText = dt;
        }
        if (mFD == INVALID_SOCKET)
            return NS_ERROR_ABORT;
    }

    // It's possible that by the time we requested post data, the web server
    // already sent EndRequest.  This is OK; the web server was still listening
    // for RequirePostData and will send it anyway, followed by a second
    // EndRequest.
    if (PeekNextBlockType() == bt_EndRequest) {
        RecvNextBlock(PR_FALSE);

        // Mark that Endrequest was seen.
        DocText *dt = (DocText *)PR_Malloc(sizeof(DocText) - sizeof(void*));
        dt->mNext = mDocText;
        dt->mLen = 0;
        mDocText = dt;
        mPostDataAfterEndRequest = PR_TRUE;
    }

    // The DocText blocks were chained in reverse order, so go reverse them into
    // the proper order.
    
    DocText *dt = nsnull;
    while (mDocText) {
        DocText *dt2 = mDocText->mNext;
        mDocText->mNext = dt;
        dt = mDocText;
        mDocText = dt2;
    }
    mDocText = dt;

    // The next block must be a PostData, even if it's empty.
    if (!RecvNextBlock(PR_FALSE))
        return NS_ERROR_ABORT;
    if (mRecvCurBlockType != bt_PostData) {
        LogFatal("Stream not positioned at PostData block.");
        g_recv.LogProtocolError(mRecvBuf + mRecvOut, mRecvIn - mRecvOut);
        CloseConnection(true);
        return NS_ERROR_ABORT;
    }

    // Post data may now be consumed.
    return NS_OK;
}
예제 #6
0
파일: FCGXStream.cpp 프로젝트: aptana/Jaxer
NS_IMETHODIMP
FCGXStream::Read(char* aBuf, PRUint32 aCount, PRUint32* aResult)
{
    // Mozilla does its HTML reading on a separate thread, so we need to own the
    // lock.  This is the *only* method called by the input pump on a non-main
    // thread.
    PR_EnterMonitor(mLock);

    // Before reading from the stream, check to see if (1) document text has
    // been set aside while waiting for post data, and (2) we have resumed
    // receiving the document.
    if (mDocText && mRecvCurBlockType != bt_PostData) {
        if (mDocText->mLen == 0) {
            // End of document was seen during accumulation.
            *aResult = 0;
            PR_Free(mDocText);
            mDocText = nsnull;
            PR_ExitMonitor(mLock);
            return NS_OK;
        }

        PRUint32 amt = mDocText->mLen - mDocTextOffset;
        if (amt > aCount) amt = aCount;
        memcpy(aBuf, mDocText->mText + mDocTextOffset, amt);
        *aResult = amt;
        mDocTextOffset += amt;

        if (mDocTextOffset == mDocText->mLen) {
            DocText *p = mDocText->mNext;

            // Save the doc for late use
            if (mDocTextTail) {
                mDocTextTail->mNext = mDocText;
                mDocTextTail = mDocTextTail->mNext;
                mDocTextTail->mNext = 0;
            }else {
                mDocTextHeader = mDocTextTail = mDocText;
                mDocText->mNext = 0;
            }

            mDocText = p;
            mDocTextOffset = 0;
        }

        PR_ExitMonitor(mLock);
        return NS_OK;
    }

    const char *p = RecvBytes(*aResult, aCount);
    if (p) {
        memcpy(aBuf, p, *aResult);

        if (mRecvCurBlockType == bt_Document) {
            // Save the data for possible late use
            DocText *dt = (DocText *)PR_Malloc(sizeof(DocText) + *aResult - sizeof(void*));
            dt->mLen = *aResult;
            memcpy(dt->mText, p, *aResult);
            dt->mNext = nsnull;

            if (!mDocTextHeader)
                mDocTextHeader = mDocTextTail = dt;
            else {
                mDocTextTail->mNext = dt;
                mDocTextTail = mDocTextTail->mNext;
            }
        }

    } else
        *aResult = 0;

    PR_ExitMonitor(mLock);
    return NS_OK;
}