VALUE rb_hps_delete(VALUE self, VALUE vkey)
{
  hashpipe_status_t *s;
  char save = '\0';
  char * key;
  VALUE val;

  // Get current value (to be returned)
  val = rb_hps_hgets(self, vkey);
  // If found,
  if(RTEST(val)) {
    // Delete key
    key = StringValueCStr(vkey);
    if(strlen(key) > 8) {
      // Already warned
      save = key[8];
      key[8] = '\0';
    }
    Data_Get_HPStruct_Ensure_Attached(self, s);
    hdel(s->buf, key);
    if(save) key[8] = save;
  }

  return val;
}
Beispiel #2
0
bool test_segfault_during_delete() {
    Table * t = makeTable();
    char * key1 = "0";
    char * key2 = "8";

    ASSERT( (hash(key1) % t->size) == (hash(key2) % t->size), "Keys will not collide. Update keys for this test.")

    hset(t, key1, "asdf");
    hset(t, key2, "asdf");

    hdel(t, key2);
    hdel(t, key1); // This segfaults

    freeTable(t);

    return true;
}
STATIC void freeData(htab *t) {
  if (t == NULL) return;
  while (hcount(t)) {
    Utils_Free(hkey(t));
    Utils_Free(hstuff(t));
    hdel(t);
  }
  hdestroy(t);
}
Beispiel #4
0
int redis_hash::hdel(const char* key, const char* first_name, ...)
{
	const char* name;
	std::vector<const char*> names;
	names.push_back(first_name);
	va_list ap;
	va_start(ap, first_name);
	while((name = va_arg(ap, const char*)) != NULL)
		names.push_back(name);
	return hdel(key, names);
}
Beispiel #5
0
bool test_remove() {
    Table * t = makeTable();
    hset(t, "Key", "A");

    char *returned = hget(t, "Key");

    ASSERT(returned != 0, "Table returned null after setting");

    hdel(t, "Key");
    
    returned = hget(t, "Key");
    //missing key returns empty string?
    ASSERT(returned[0] == 0, "Table returned non-null");

    return true;
}
uint64_t CRedisClient::hdel( const string &key, const CRedisClient::VecString &fields )
{
    CResult result;
    hdel( key, fields, result );

    ReplyType type = result.getType();

    if ( REDIS_REPLY_ERROR == type )
    {
        throw ReplyErr( result.getErrorString() );
    }else if ( REDIS_REPLY_INTEGERER != type )
    {
        throw ProtocolErr( "HDEL: data recv is not intgerer" );
    }
    return result.getInt();
}
Beispiel #7
0
int main() {
    int (**table)[2] = hnew();

    hset(table, 10, 20);
    hset(table, 20, 30);
    hset(table, 30, 40);

    int (**a)[2] = hget(table, 10);
    int (**b)[2] = hget(table, 20);
    int (**c)[2] = hget(table, 30);

    printf("%d:%d\n", (**a)[0], (**a)[1]);
    printf("%d:%d\n", (**b)[0], (**b)[1]);
    printf("%d:%d\n", (**c)[0], (**c)[1]);

    hdel(table);
}
STATIC bool clearKey(const SecureStorageS *storage, const unsigned char *key) {
  int16_t len = 0;
  htab *t = NULL;

  if (storage == NULL || key == NULL) {
    assert(LIB_NAME "Storage structure and key string must not be NULL" && (false || Storage_TestMode));
    return false;
  }
  t = storage->Data;
  if (Utils_GetCharArrayLen(key, &len, KEY_VAL_MIN_STR_LEN, KEY_VAL_MAX_STR_LEN) == false) return false;
  if (key != NULL && hfind(t, key, len + UTILS_STR_LEN_SIZE) == true) { // override existing item
    Utils_Free(hkey(t));
    Utils_Free(hstuff(t));
    hdel(t);
    return true;
  }
  return false;
}
int main(int argc, char *argv[]) {

    int instance_id = 0;
    hashpipe_status_t *s;

    /* Loop over cmd line to fill in params */
    static struct option long_opts[] = {
        {"help",   0, NULL, 'h'},
        {"shmkey", 1, NULL, 'K'},
        {"key",    1, NULL, 'k'},
        {"get",    1, NULL, 'g'},
        {"string", 1, NULL, 's'},
        {"float",  1, NULL, 'f'},
        {"double", 1, NULL, 'd'},
        {"int",    1, NULL, 'i'},
        {"verbose",  0, NULL, 'v'},
        {"clear",  0, NULL, 'C'},
        {"del",    0, NULL, 'D'},
        {"query",  1, NULL, 'Q'},
        {"instance", 1, NULL, 'I'},
        {0,0,0,0}
    };
    int opt,opti;
    char *key=NULL;
    char value[81];
    float flttmp;
    double dbltmp;
    int inttmp;
    int verbose=0, clear=0;
    char keyfile[1000];
    while ((opt=getopt_long(argc,argv,"hk:g:s:f:d:i:vCDQ:K:I:",long_opts,&opti))!=-1) {
        switch (opt) {
            case 'K': // Keyfile
                snprintf(keyfile, sizeof(keyfile), "HASHPIPE_KEYFILE=%s", optarg);
                keyfile[sizeof(keyfile)-1] = '\0';
                putenv(keyfile);
                break;
            case 'I':
                instance_id = atoi(optarg);
                break;
            case 'k':
                key = optarg;
                break;
            case 'Q':
                s = get_status_buffer(instance_id);
                hashpipe_status_lock(s);
                hgets(s->buf, optarg, 80, value);
                hashpipe_status_unlock(s);
                value[80] = '\0';
                printf("%s\n", value);
                break;
            case 'g':
                s = get_status_buffer(instance_id);
                hashpipe_status_lock(s);
                hgetr8(s->buf, optarg, &dbltmp);
                hashpipe_status_unlock(s);
                printf("%g\n", dbltmp);
                break;
            case 's':
                if (key) {
                    s = get_status_buffer(instance_id);
                    hashpipe_status_lock(s);
                    hputs(s->buf, key, optarg);
                    hashpipe_status_unlock(s);
                }
                break;
            case 'f':
                flttmp = atof(optarg);
                if (key) {
                    s = get_status_buffer(instance_id);
                    hashpipe_status_lock(s);
                    hputr4(s->buf, key, flttmp);
                    hashpipe_status_unlock(s);
                }
                break;
            case 'd':
                dbltmp = atof(optarg);
                if (key) {
                    s = get_status_buffer(instance_id);
                    hashpipe_status_lock(s);
                    hputr8(s->buf, key, dbltmp);
                    hashpipe_status_unlock(s);
                }
                break;
            case 'i':
                inttmp = atoi(optarg);
                if (key) {
                    s = get_status_buffer(instance_id);
                    hashpipe_status_lock(s);
                    hputi4(s->buf, key, inttmp);
                    hashpipe_status_unlock(s);
                }
                break;
            case 'D':
                if (key) {
                    s = get_status_buffer(instance_id);
                    hashpipe_status_lock(s);
                    hdel(s->buf, key);
                    hashpipe_status_unlock(s);
                }
                break;
            case 'C':
                clear=1;
                break;
            case 'v':
                verbose=1;
                break;
            case 'h':
                usage();
                return 0;
            case '?': // Command line parsing error
            default:
                usage();
                exit(1);
                break;
        }
    }

    s = get_status_buffer(instance_id);

    /* If verbose, print out buffer */
    if (verbose) { 
        hashpipe_status_lock(s);
        printf("%s\n", s->buf);
        hashpipe_status_unlock(s);
    }

    if (clear) 
        hashpipe_status_clear(s);

    exit(0);
}
int main(int argc, char *argv[]) {

    int rv;
    struct vegas_status s;

    rv = vegas_status_attach(&s);
    if (rv!=VEGAS_OK) {
        fprintf(stderr, "Error connecting to shared mem.\n");
        perror(NULL);
        exit(1);
    }

    vegas_status_lock(&s);

    /* Loop over cmd line to fill in params */
    static struct option long_opts[] = {
        {"key",    1, NULL, 'k'},
        {"get",    1, NULL, 'g'},
        {"string", 1, NULL, 's'},
        {"float",  1, NULL, 'f'},
        {"double", 1, NULL, 'd'},
        {"int",    1, NULL, 'i'},
        {"quiet",  0, NULL, 'q'},
        {"clear",  0, NULL, 'C'},
        {"del",    0, NULL, 'D'},
        {0,0,0,0}
    };
    int opt,opti;
    char *key=NULL;
    float flttmp;
    double dbltmp;
    int inttmp;
    int quiet=0, clear=0;
    while ((opt=getopt_long(argc,argv,"k:g:s:f:d:i:qCD",long_opts,&opti))!=-1) {
        switch (opt) {
            case 'k':
                key = optarg;
                break;
            case 'g':
                hgetr8(s.buf, optarg, &dbltmp);
                printf("%g\n", dbltmp);
                break;
            case 's':
                if (key) 
                    hputs(s.buf, key, optarg);
                break;
            case 'f':
                flttmp = atof(optarg);
                if (key) 
                    hputr4(s.buf, key, flttmp);
                break;
            case 'd':
                dbltmp = atof(optarg);
                if (key) 
                    hputr8(s.buf, key, dbltmp);
                break;
            case 'i':
                inttmp = atoi(optarg);
                if (key) 
                    hputi4(s.buf, key, inttmp);
                break;
            case 'D':
                if (key)
                    hdel(s.buf, key);
                break;
            case 'C':
                clear=1;
                break;
            case 'q':
                quiet=1;
                break;
            default:
                break;
        }
    }

    /* If not quiet, print out buffer */
    if (!quiet) { 
        printf(s.buf); printf("\n"); 
    }

    vegas_status_unlock(&s);

    if (clear) 
        vegas_status_clear(&s);

    exit(0);
}
Beispiel #11
0
void type()
{
    int i, j, jjbo, icount,ncarbon, nhyd;

    icount = 0;
    ncarbon = 0;
    nhyd = 0;
    for (i=1; i <= natom; i++)
    {
        if (atom[i].atomnum == 6)
        {
            jjbo = 0;
            for (j=0; j < MAXIAT; j++)
            {
                if (atom[i].iat[j] != 0 && atom[i].bo[j] != 9)
                    jjbo += atom[i].bo[j];
                if (atom[atom[i].iat[j]].atomnum == 1)
                    nhyd++;
            }
            if ( jjbo < 3 && atom[i].mmx_type == 40 && icount > 0  )
            {
                quick_type();
                set_atomtypes(field.type);
                return;
            } else if (jjbo < 4 && atom[i].mmx_type != 40 && icount > 0)
            {
                quick_type();
                set_atomtypes(field.type);
                return;
            } else
            {
                icount++;
                ncarbon++;
            }
            if (icount > 15)
                break;
        } else if (atom[i].atomnum == 8)
        {
            jjbo = 0;
            for (j=0; j < MAXIAT; j++)
            {
                if (atom[i].iat[j] != 0 && atom[i].bo[j] != 9)
                    jjbo += atom[i].bo[j];
            }
            if (jjbo < 1 && icount > 0)
            {
                quick_type();
                set_atomtypes(field.type);
                return;
            } else if (jjbo == 1 && icount > 0 && atom[i].mmx_type == 6)
            {
                quick_type();
                set_atomtypes(field.type);
                return;
            } else
                icount++;
            if (icount > 15)
                break;
        }

    }
    if (ncarbon > 0 && nhyd == 0)  // pathological cases where there are no carbons, or no carbons that normally have hydrogens
    {
        type_mmx();
        set_atomtypes(field.type);
        return;
    }
// normal typing routines
    if (field.type == MMX)
    {
        type_mmx();
        set_atomtypes(MMX);
    } else if (field.type == MM3)
    {
        for (i=1; i <= natom; i++)
        {
            if (atom[i].mmx_type == 20)
            {
                hdel(1);
                break;
            }
        }
        type_mmx();
        set_atomtypes(MM3);
    } else if (field.type == MMFF94)
    {
        for (i=1; i <= natom; i++)
        {
            if (atom[i].mmx_type == 20)
            {
                hdel(1);
                break;
            }
        }
        type_mmx();
        set_atomtypes(MMFF94);
    } else if (field.type == AMBER)
    {
        for (i=1; i <= natom; i++)
        {
            if (atom[i].mmx_type == 20)
            {
                hdel(1);
                break;
            }
        }
        type_mmx();
        set_atomtypes(AMBER);
    } else if (field.type == OPLSAA)
    {
        for (i=1; i <= natom; i++)
        {
            if (atom[i].mmx_type == 20)
            {
                hdel(1);
                break;
            }
        }
        type_mmx();
        set_atomtypes(OPLSAA);
    }
    else
        message_alert("No typing rules for this force field are implemented!","ERROR");
}
Beispiel #12
0
// ==================================================
void pcmfout(int mode)
{
        FILE    *wfile;
        int icoord, imetflag, ispin,lps;
        int i,j, itype;

        /*  Mode = 1 normal packed write operation
         *  Mode = 2 fast no questions asked unpacked write of pcmod.bak
         *  Mode = 3 fast no questions ot file = wfile
         *  mode = 4 start of minim to pcmod.bak but ask questions about pi */

	wfile = NULL;
	itype = 0;
        if( mode == 1 )
        {
                /* assume append is set when we get a filename that exists */
                /* put up dialog box with current structure title, pi flags
                   and added constants question */
           if( files.append )
              wfile = fopen_path(Savebox.path,Savebox.fname,"a");
           else
              wfile = fopen_path(Savebox.path,Savebox.fname,"w");
        }
        else if( mode == 2 || mode == 4 )
        {
              wfile = fopen_path(pcwindir,"pcmod.bak","w");
        }
        else if( mode == 3 )
        {
           if( files.append )
              wfile = fopen_path(Savebox.path,Savebox.fname,"a");
           else
              wfile = fopen_path(Savebox.path,Savebox.fname,"w");
        }
        if (wfile == NULL)
        {
                message_alert("Error opening file in PCMFOUT. Cannot create file","PCM File");
                return;
        }
// remove lone pairs if not writing mmx types
        lps = FALSE;
        if (default_outtype != MMX)
        {
            for (i=1; i <= natom; i++)
            {
                if (atom[i].mmx_type == 20)
                {
                    lps = TRUE;
                    break;
                }
            }
        }
        if (lps == TRUE)
           hdel(1);
        
/* start of file writing  */
        fprintf(wfile,"{PCM %s\n",Struct_Title);
        fprintf(wfile,"NA %d\n",natom);
// optimization information
        fprintf(wfile,"OPT PARA %d CONV %d IE %8.3f FE %8.3f IH %8.3f FH %8.3f\n",optimize_data.param_avail,
           optimize_data.converge,optimize_data.initial_energy,optimize_data.final_energy,
           optimize_data.initial_heat,optimize_data.final_heat);    
/*  flags  */
        fprintf(wfile,"FL ");
        fprintf(wfile,"EINT%d ",minim_values.ndc);
        if( pistuf.iuv )
                fprintf(wfile,"UV%d ",pistuf.iuv);
        if( pistuf.nplane )
                fprintf(wfile,"PIPL%d ",pistuf.nplane);
        if( pistuf.jprint )
                fprintf(wfile,"PIPR%d ",pistuf.jprint);
        if( units.dielec != 1.5 )
                fprintf(wfile,"DIELC%f ",units.dielec);
        fprintf(wfile,"\n");
//  default output filetypes
        fprintf(wfile,"ATOMTYPES %d\n",default_outtype);
/*
        if( minim_values.nconst && mode > 1 )
                fprintf(wfile,"CO FILE %s\n",constf.cname);*/
/*  atoms and bonds lists */
        for( i = 1; i <= natom; i++ )
        {
            if (default_outtype == MMX)
            {
                itype = atom[i].mmx_type;
            } else if (default_outtype == MM3)
            {
                itype = atom[i].mm3_type;
            } else if (default_outtype == MMFF94)
            {
                itype = atom[i].mmff_type;
            }
            fprintf(wfile,"AT %d %d %8.4f %8.4f %8.4f",i,itype,atom[i].x,
                                atom[i].y, atom[i].z);
// bonds
                fprintf(wfile," B");
                for( j = 0; j < MAXIAT; j++ )
                {
                        if( atom[i].iat[j])
                        {
                                fprintf(wfile," %d %d",atom[i].iat[j],atom[i].bo[j]);
                        }
                }
                if( atom[i].flags & (1L << HBOND_MASK) )
                        fprintf(wfile," H ");
                if( atom[i].flags & (1L << PI_MASK) )
                        fprintf(wfile," P ");
                if( atom[i].mmx_type >= 300 )
                {
                        icoord = 0;
                        ispin = -1;
                        imetflag = 0;
                        if( atom[i].flags & (1L << SATMET_MASK) )
                                imetflag += 2;
                        if( atom[i].flags & (1L << GT18e_MASK) )
                                imetflag += 1;
                        if( imetflag == 2 )
                                icoord = 0;
                        if( imetflag == 1 )
                                icoord = 2;
                        if( imetflag == 3 )
                        {
                                icoord = 1;
                                imetflag = 0;
                                if( atom[i].flags & (1L << LOWSPIN_MASK) )
                                        imetflag += 2;
                                if( atom[i].flags & (1L << SQPLAN_MASK) )
                                        imetflag += 1;
                                if( imetflag == 2 )
                                        ispin = 0;
                                if( imetflag == 3 )
                                        ispin = 2;
                                if( imetflag == 1 )
                                        ispin = 1;
                        }
                        if( icoord )
                        {
                                fprintf(wfile," M %d",icoord);
                                if( ispin >= 0 )
                                        fprintf(wfile," %d",ispin);
                        }
                        fprintf(wfile," R %g",atom[i].radius);
                }
                if( atom[i].charge )
                {
                        fprintf(wfile," C %g",atom[i].charge);
                }
                fprintf(wfile,"\n");
        }
        if( fxtor.nfxtor == 1 || fxtor.nfxtor == 2 )
        {
                fprintf(wfile,"DD %d %d %d %d FROM %d TO %d BY %d\n",fxtor.iatom[0][0],  
                 fxtor.iatom[0][1], fxtor.iatom[0][2], fxtor.iatom[0][3], fxtor.start_ang[0],
                 fxtor.final_ang[0], fxtor.step[0] );
                if( fxtor.nfxtor == 2 )
                {
                     fprintf(wfile,"DD %d %d %d %d FROM %d TO %d BY %d\n",fxtor.iatom[1][0],  
                        fxtor.iatom[1][1], fxtor.iatom[1][2], fxtor.iatom[1][3], fxtor.start_ang[1],
                        fxtor.final_ang[1], fxtor.step[1] );
                }
        }
        if (fixdis.nfxstr)
        {
                for( i = 0; i < fixdis.nfxstr; i++ )
                {
                fprintf(wfile,"FIX DIS %d %d R %7.3f K %7.3f\n",fixdis.ifxstr[i][0], 
                                fixdis.ifxstr[i][1], fixdis.fxstrd[i], fixdis.fxstrc[i] );
                }
        }
        for (i=0; i < 15; i++)
        {
                if (ts_bondorder.fbnd[i] > 0.0F)
                {
                        fprintf(wfile,"FBND");
                        for (j=0; j<15; j++)
                        {
                                fprintf(wfile," %5.3f",ts_bondorder.fbnd[j]);
                        }
                        fprintf(wfile,"\n");
                        break;
                }
        }
        
        fprintf(wfile,"}\n");
        fclose(wfile);
} /* end of function */
static void *run(hashpipe_thread_args_t * args)
{
    // Local aliases to shorten access to args fields
    // Our output buffer happens to be a paper_input_databuf
    hashpipe_status_t st = args->st;
    const char * status_key = args->thread_desc->skey;

    st_p = &st;	// allow global (this source file) access to the status buffer

    // Get inital value for crc32 function
    uint32_t init_crc = crc32(0,0,0);

    // Flag that holds off the crc thread
    int holdoff = 1;

    // Force ourself into the hold off state
    hashpipe_status_lock_safe(&st);
    hputi4(st.buf, "CRCHOLD", 1);
    hashpipe_status_unlock_safe(&st);

    while(holdoff) {
	// We're not in any hurry to startup
	sleep(1);
	hashpipe_status_lock_safe(&st);
	// Look for CRCHOLD value
	hgeti4(st.buf, "CRCHOLD", &holdoff);
	if(!holdoff) {
	    // Done holding, so delete the key
	    hdel(st.buf, "CRCHOLD");
	}
	hashpipe_status_unlock_safe(&st);
    }

    /* Read network params */
    struct hashpipe_udp_params up = {
	.bindhost = "0.0.0.0",
	.bindport = 8511,
	.packet_size = 8200
    };
    hashpipe_status_lock_safe(&st);
    // Get info from status buffer if present (no change if not present)
    hgets(st.buf, "BINDHOST", 80, up.bindhost);
    hgeti4(st.buf, "BINDPORT", &up.bindport);
    // Store bind host/port info etc in status buffer
    hputs(st.buf, "BINDHOST", up.bindhost);
    hputi4(st.buf, "BINDPORT", up.bindport);
    hputu4(st.buf, "CRCPKOK", 0);
    hputu4(st.buf, "CRCPKERR", 0);
    hputs(st.buf, status_key, "running");
    hashpipe_status_unlock_safe(&st);

    struct hashpipe_udp_packet p;

    /* Give all the threads a chance to start before opening network socket */
    sleep(1);


    /* Set up UDP socket */
    int rv = hashpipe_udp_init(&up);
    if (rv!=HASHPIPE_OK) {
        hashpipe_error("paper_crc_thread",
                "Error opening UDP socket.");
        pthread_exit(NULL);
    }
    pthread_cleanup_push((void *)hashpipe_udp_close, &up);

    /* Main loop */
    uint64_t packet_count = 0;
    uint64_t good_count = 0;
    uint64_t error_count = 0;
    uint64_t elapsed_wait_ns = 0;
    uint64_t elapsed_recv_ns = 0;
    uint64_t elapsed_proc_ns = 0;
    float ns_per_wait = 0.0;
    float ns_per_recv = 0.0;
    float ns_per_proc = 0.0;
    struct timespec start, stop;
    struct timespec recv_start, recv_stop;
    packet_header_t hdr;

    while (run_threads()) {

        /* Read packet */
	clock_gettime(CLOCK_MONOTONIC, &recv_start);
	do {
	    clock_gettime(CLOCK_MONOTONIC, &start);
	    p.packet_size = recv(up.sock, p.data, HASHPIPE_MAX_PACKET_SIZE, 0);
	    clock_gettime(CLOCK_MONOTONIC, &recv_stop);
	} while (p.packet_size == -1 && (errno == EAGAIN || errno == EWOULDBLOCK) && run_threads());

	// Break out of loop if stopping
	if(!run_threads()) break;

	// Increment packet count
	packet_count++;

	// Check CRC
        if(crc32(init_crc, (/*const?*/ uint8_t *)p.data, p.packet_size) == 0xffffffff) {
	    // CRC OK! Increment good counter
	    good_count++;
	} else {
	    // CRC error!  Increment error counter
	    error_count++;

	    // Log message
	    get_header(&p, &hdr);
	    hashpipe_warn("paper_crc", "CRC error mcnt %llu ; fid %u ; xid %u",
		    hdr.mcnt, hdr.fid, hdr.xid);
	}

	clock_gettime(CLOCK_MONOTONIC, &stop);
	elapsed_wait_ns += ELAPSED_NS(recv_start, start);
	elapsed_recv_ns += ELAPSED_NS(start, recv_stop);
	elapsed_proc_ns += ELAPSED_NS(recv_stop, stop);

        if(packet_count % 1000 == 0) {
	    // Compute stats
	    get_header(&p, &hdr);
            ns_per_wait = (float)elapsed_wait_ns / packet_count;
            ns_per_recv = (float)elapsed_recv_ns / packet_count;
            ns_per_proc = (float)elapsed_proc_ns / packet_count;

            // Update status
            hashpipe_status_lock_busywait_safe(&st);
            hputu8(st.buf, "CRCMCNT", hdr.mcnt);
	    // Gbps = bits_per_packet / ns_per_packet
	    // (N_BYTES_PER_PACKET excludes header, so +8 for the header)
            hputr4(st.buf, "CRCGBPS", 8*(N_BYTES_PER_PACKET+8)/(ns_per_recv+ns_per_proc));
            hputr4(st.buf, "CRCWATNS", ns_per_wait);
            hputr4(st.buf, "CRCRECNS", ns_per_recv);
            hputr4(st.buf, "CRCPRCNS", ns_per_proc);
	    // TODO Provide some way to recognize request to zero out the
	    // CRCERR and CRCOK fields.
	    hputu8(st.buf, "CRCPKOK",  good_count);
	    hputu8(st.buf, "CRCPKERR", error_count);
            hashpipe_status_unlock_safe(&st);

	    // Start new average
	    elapsed_wait_ns = 0;
	    elapsed_recv_ns = 0;
	    elapsed_proc_ns = 0;
	    packet_count = 0;
        }

        /* Will exit if thread has been cancelled */
        pthread_testcancel();
    }

    /* Have to close all push's */
    pthread_cleanup_pop(1); /* Closes push(hashpipe_udp_close) */

    return NULL;
}

static hashpipe_thread_desc_t crc_thread = {
    name: "paper_crc_thread",
    skey: "CRCSTAT",
    init: NULL,
    run:  run,
    ibuf_desc: {NULL},