static int xdr_RPGP_location_t (XDR *xdrs, RPGP_location_t *loc) { if (xdr_float (xdrs, &(loc->lat)) == 0 || xdr_float (xdrs, &(loc->lon)) == 0) return (0); return (1); }
bool_t xdr_rpc_loc_assist_data_pos_s_type (XDR *xdrs, rpc_loc_assist_data_pos_s_type *objp) { register int32_t *buf; if (!xdr_rpc_loc_assist_pos_valid_mask_type (xdrs, &objp->valid_mask)) return FALSE; if (!xdr_rpc_uint64 (xdrs, &objp->timestamp_utc)) return FALSE; if (!xdr_double (xdrs, &objp->latitude)) return FALSE; if (!xdr_double (xdrs, &objp->longitude)) return FALSE; if (!xdr_float (xdrs, &objp->altitude_wrt_ellipsoid)) return FALSE; if (!xdr_float (xdrs, &objp->altitude_wrt_mean_sea_level)) return FALSE; if (!xdr_float (xdrs, &objp->hor_unc_circular)) return FALSE; if (!xdr_float (xdrs, &objp->vert_unc)) return FALSE; if (!xdr_u_char (xdrs, &objp->confidence_horizontal)) return FALSE; if (!xdr_u_char (xdrs, &objp->confidence_vertical)) return FALSE; if (!xdr_rpc_int32 (xdrs, &objp->timestamp_age)) return FALSE; return TRUE; }
bool_t xdr_rpc_loc_sv_info_s_type (XDR *xdrs, rpc_loc_sv_info_s_type *objp) { register int32_t *buf; if (!xdr_rpc_loc_sv_info_valid_mask_type (xdrs, &objp->valid_mask)) return FALSE; if (!xdr_rpc_loc_sv_system_e_type (xdrs, &objp->system)) return FALSE; if (!xdr_rpc_uint8 (xdrs, &objp->prn)) return FALSE; if (!xdr_rpc_uint8 (xdrs, &objp->health_status)) return FALSE; if (!xdr_rpc_loc_sv_status_e_type (xdrs, &objp->process_status)) return FALSE; if (!xdr_rpc_boolean (xdrs, &objp->has_eph)) return FALSE; if (!xdr_rpc_boolean (xdrs, &objp->has_alm)) return FALSE; if (!xdr_float (xdrs, &objp->elevation)) return FALSE; if (!xdr_float (xdrs, &objp->azimuth)) return FALSE; if (!xdr_float (xdrs, &objp->snr)) return FALSE; return TRUE; }
static int xdr_RPGP_radial_t (XDR *xdrs, RPGP_radial_t *radial) { if (xdrs->x_op == XDR_DECODE) { radial->description = NULL; radial->comp_params = NULL; radial->radials = NULL; } if (xdr_int (xdrs, &(radial->comp_type)) == 0 || xdr_string (xdrs, &(radial->description), MAX_ARRAY_SIZE) == 0 || xdr_float (xdrs, &(radial->bin_size)) == 0 || xdr_float (xdrs, &(radial->first_range)) == 0 || xdr_int (xdrs, &(radial->numof_comp_params)) == 0 || (radial->numof_comp_params > 0 && xdr_array (xdrs, (char **)&(radial->comp_params), (unsigned int *)&(radial->numof_comp_params), MAX_ARRAY_SIZE, sizeof (RPGP_parameter_t), (xdrproc_t)xdr_RPGP_parameter_t) == 0) || xdr_int (xdrs, &(radial->numof_radials)) == 0) return (0); if (radial->numof_radials > 0) { if (xdr_array (xdrs, (char **)&(radial->radials), (unsigned int *)&(radial->numof_radials), MAX_ARRAY_SIZE, sizeof (RPGP_radial_data_t), (xdrproc_t)xdr_RPGP_radial_data_t) == 0) return (0); } return (1); }
int main (int argc, char *argv[]) { XDR xdr_encode, xdr_decode; char tab[TAILLE]; int entier = -1001 ; float reel = 3.14; char *chaine0 = "Bingo !"; char *chaine1 = "Re Bingo !"; char *ptr0 = NULL; char *ptr1 = NULL; /* Creation des flots XDR, c.a.d. "suites de donnes accessibles en lecture ou ecriture (comparables en cela a la structure FILE). Une telle suite de donnees supporte d'etre ecrit puis lu sur des plate-formes differentes". La structure XDR representant le flot dispose notamment : d'un tampon, d'un curseur, du parametre permettant de choisir entre encodage OU decodage */ xdrmem_create(&xdr_encode, tab, TAILLE, XDR_ENCODE); xdrmem_create(&xdr_decode, tab, TAILLE, XDR_DECODE); /* Encodage dans un flot XDR ------------ */ if (!xdr_int(&xdr_encode, &entier)) fprintf(stdout,"Erreur d'encodage de l'entier\n"); if (!xdr_float(&xdr_encode, &reel)) fprintf(stdout,"Erreur d'encodage du reel\n"); if (!xdr_string(&xdr_encode, &chaine0, LONGCHAINE)) fprintf(stdout,"Erreur d'encodage de la chaine 0\n"); if (!xdr_string(&xdr_encode, &chaine1, LONGCHAINE)) fprintf(stdout,"Erreur d'encodage de la chaine 1\n"); /* Decodage du flot XDR */ entier = 0; reel = 0; if (!xdr_int(&xdr_decode, &entier)) fprintf(stdout,"Erreur de decodage de l'entier\n"); else fprintf(stdout,"Entier lu : %d\n",entier); if (!xdr_float(&xdr_decode, &reel)) fprintf(stdout,"Erreur de decodage du reel\n"); else fprintf(stdout,"Reel lu : %f\n",reel); ptr1 = malloc(LONGCHAINE*sizeof(char)); fprintf(stdout,"les pointeurs sur les chaines : %x %x\n",ptr0,ptr1); if (!xdr_string(&xdr_decode, &ptr0, LONGCHAINE)) fprintf(stdout,"Erreur decodage chaine 0\n"); else fprintf(stdout,"Chaine lue : %s\n",ptr0); if (!xdr_string(&xdr_decode, &ptr1, LONGCHAINE)) fprintf(stdout,"Erreur decodage chaine 1\n"); else fprintf(stdout,"Chaine lue : %s\n",ptr1); fprintf(stdout,"les pointeurs sur les chaines : %x %x\n",ptr0,ptr1); return(0); }
int mr1_xdrsidev1(PingSide *ps, XDR *xdrs) /* Internal routine. Does XDR decoding of an obsolete MR1 version 1 PingSide header. Returns 1 if successful, 0 otherwise. */ { /* output in obsolete version 1 format not allowed! */ if (xdrs->x_op == XDR_ENCODE) return 0; if (!nan_init) { nan_f= mr1_nanf(); nan_d= mr1_nand(); nan_init= 1; } /* HMRG code never archived anything to the old ps_trans[] fields, so their contents are meaningless -- this code reads those meaningless values and then stores a NaN to the new ps_xmitpwr field */ if (!xdr_float(xdrs, &(ps->ps_xmitpwr))) return 0; if (!xdr_float(xdrs, &(ps->ps_xmitpwr))) return 0; ps->ps_xmitpwr= nan_f; /* HMRG code never archived anything to the ps_gain field prior to the format version 2 changeover -- this code reads that meaningless value and then stores a NaN to the ps_gain field */ if (!xdr_float(xdrs, &(ps->ps_gain))) return 0; ps->ps_gain= nan_f; /* HMRG code never archived anything to the ps_pulse field prior to the format version 2 changeover with the exception of one format conversion program (sb4b2mr) -- this code reads that value and then replaces it with a NaN unless it is non-zero */ if (!xdr_float(xdrs, &(ps->ps_pulse))) return 0; if (ps->ps_pulse == 0.) ps->ps_pulse= nan_f; if (!xdr_int(xdrs, &(ps->ps_btycount))) return 0; if (xdrs->x_op == XDR_DECODE) ps->ps_btypad= 0; if (!xdr_float(xdrs, &(ps->ps_ssoffset))) return 0; if (!xdr_int(xdrs, &(ps->ps_sscount))) return 0; if (xdrs->x_op == XDR_DECODE) ps->ps_sspad= 0; return 1; }
static int xdr_thresholds(XDR *xdrs, struct jobSpecs *jobSpecs) { static char fname[] = "xdr_thresholds"; int i, j; if (xdrs->x_op == XDR_DECODE) { jobSpecs->thresholds.loadSched = NULL; jobSpecs->thresholds.loadStop = NULL; } if (xdrs->x_op == XDR_FREE) { for(i=0; i < jobSpecs->thresholds.nThresholds; i++) { FREEUP(jobSpecs->thresholds.loadSched[i]); FREEUP(jobSpecs->thresholds.loadStop[i]); } FREEUP(jobSpecs->thresholds.loadSched); FREEUP(jobSpecs->thresholds.loadStop); return(TRUE); } if (!(xdr_int(xdrs, &jobSpecs->thresholds.nIdx) && xdr_int(xdrs, &jobSpecs->thresholds.nThresholds))) { ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname, lsb_jobid2str(jobSpecs->jobId), "xdr_int", "nIdx/nThresholds"); return(FALSE); } if (xdrs->x_op == XDR_DECODE) { jobSpecs->thresholds.loadSched = (float **) my_calloc (jobSpecs->thresholds.nThresholds, sizeof(float *), fname); jobSpecs->thresholds.loadStop = (float **) my_calloc (jobSpecs->thresholds.nThresholds, sizeof(float *), fname); for (i = 0; i < jobSpecs->thresholds.nThresholds; i++) { jobSpecs->thresholds.loadSched[i] = (float *) my_calloc (jobSpecs->thresholds.nIdx, sizeof(float), fname); jobSpecs->thresholds.loadStop[i] = (float *) my_calloc (jobSpecs->thresholds.nIdx, sizeof(float), fname); } } for (j = 0; j < jobSpecs->thresholds.nThresholds; j++) { for (i = 0; i < jobSpecs->thresholds.nIdx; i++) { if (!(xdr_float(xdrs, &jobSpecs->thresholds.loadStop[j][i]) && xdr_float(xdrs, &jobSpecs->thresholds.loadSched[j][i]))) { ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname, lsb_jobid2str(jobSpecs->jobId), "xdr_float", "loadStop/loadSched"); return(FALSE); } } } return (TRUE); }
bool_t xdr_flotantes (XDR *xdrs, flotantes *objp) { register int32_t *buf; if (!xdr_float (xdrs, &objp->a)) return FALSE; if (!xdr_float (xdrs, &objp->b)) return FALSE; return TRUE; }
bool_t xdr_inputs (XDR *xdrs, inputs *objp) { register int32_t *buf; if (!xdr_float (xdrs, &objp->num1)) return FALSE; if (!xdr_float (xdrs, &objp->num2)) return FALSE; if (!xdr_char (xdrs, &objp->operator)) return FALSE; return TRUE; }
static int xdr_RPGP_radial_data_t (XDR *xdrs, RPGP_radial_data_t *radial_d) { if (xdr_float (xdrs, &(radial_d->azimuth)) == 0 || xdr_float (xdrs, &(radial_d->elevation)) == 0 || xdr_float (xdrs, &(radial_d->width)) == 0 || xdr_int (xdrs, &(radial_d->n_bins)) == 0) return (0); if (radial_d->n_bins > 0) { if (xdr_RPGP_data_t (xdrs, &(radial_d->bins), radial_d->n_bins) == 0) return (0); } return (1); }
static int xdr_Calib(XDR *xdrs, AHRecord *rec) { vector<float> cal(120); if (xdrs->x_op == XDR_ENCODE) { int n=rec->cal.size(); for(int i=0;i<n; i++) { cal[i] = rec->cal[i]; } for(int i=n;i<120; i++) { cal[i] = 0; } } for (int i=0; i<120; i++) { if ( ! xdr_float(xdrs, &(cal[i]))) { return 0; } } if (xdrs->x_op == XDR_DECODE) { rec->cal = cal; } return 1; }
main () { FILE *fp; /*указатель файла */ XDR xdrs; /*дескpиптоp XDR */ long val1=10; /*целое */ float val2=4.456789; /*с плавающей точкой */ char val3s[] = "qwerty123456uvwxyz"; /* 18+1 bytes null terminated string */ char *val3; int r; val3 = malloc(20); strcpy(val3,val3s); /*откpытие файла на запись */ fp = fopen(FIC, "w"); /* создание потока XDR для кодиpования */ xdrstdio_create(&xdrs, fp, XDR_ENCODE); /*запись целого */ xdr_long(&xdrs, &val1); /*запись числа с плавающей точкой */ xdr_float(&xdrs, &val2); /* write string */ r = xdr_string(&xdrs, &val3, strlen(val3)); printf("r=%d\n",r); free(val3); fclose(fp); exit(0); }
float *kdReadFloatArray(char *filename, int bAscii, char *arrayName) // Reads a tipsy array file { XDR xdrs; FILE *fp; long np; float *arr, temp; int i; char arrFile[256]; strcpy(arrFile, filename); strcat(arrFile, "."); strcat(arrFile, arrayName); fprintf(stderr, "array = %s\n", arrFile); if (!bAscii) { assert(sizeof(Real)==sizeof(float)); /* Otherwise, this XDR stuff ain't gonna work */ fp = fopen(arrFile, "r"); xdrstdio_create(&xdrs, fp, XDR_DECODE); xdr_long(&xdrs, &np); arr = malloc(sizeof(float)*np); for(i=0;i<np;i++) xdr_float(&xdrs,&temp); } fclose(fp); return arr; }
bool_t xdr_rpc_loc_fix_criteria_s_type (XDR *xdrs, rpc_loc_fix_criteria_s_type *objp) { register int32_t *buf; if (!xdr_rpc_uint32 (xdrs, &objp->valid_mask)) return FALSE; if (!xdr_rpc_loc_fix_recurrence_e_type (xdrs, &objp->recurrence_type)) return FALSE; if (!xdr_rpc_loc_operation_mode_e_type (xdrs, &objp->preferred_operation_mode)) return FALSE; if (!xdr_rpc_uint32 (xdrs, &objp->preferred_accuracy)) return FALSE; if (!xdr_rpc_uint32 (xdrs, &objp->preferred_response_time)) return FALSE; if (!xdr_rpc_boolean (xdrs, &objp->intermediate_pos_report_enabled)) return FALSE; if (!xdr_rpc_loc_notify_e_type (xdrs, &objp->notify_type)) return FALSE; if (!xdr_rpc_uint32 (xdrs, &objp->min_interval)) return FALSE; if (!xdr_float (xdrs, &objp->min_distance)) return FALSE; if (!xdr_rpc_uint32 (xdrs, &objp->min_dist_sample_interval)) return FALSE; return TRUE; }
bool_t xdr_matrix(XDR *xdrs, Matrix* e) { int i,j; int dim; Matrix m; if (xdrs->x_op==XDR_ENCODE){ m=(*e); dim=m->dim; if(xdr_int(xdrs,&dim)!=TRUE) return FALSE; }else if (xdrs->x_op==XDR_DECODE){ if(xdr_int(xdrs,&dim)!=TRUE) return FALSE; printf("%d\n",dim); m=new_matrix(dim); m->dim=dim; (*e)=m; } for (i = 0; i < dim; i++) { for (j = 0; j < dim; j++) { if(xdr_float(xdrs,&(m->mat[i][j]))!=TRUE) return FALSE; } } return TRUE; }
static int xdr_Time(XDR *xdrs, Core::Time *t) { int yr, mo, day, hr, mn, sec, usec; float fsec; if (xdrs->x_op == XDR_ENCODE) { t->get(&yr, &mo, &day, &hr, &mn, &sec, &usec); fsec = sec + 0.000001*usec; } if ( ! xdr_int(xdrs, &yr)) return 0; if ( ! xdr_int(xdrs, &mo)) return 0; if ( ! xdr_int(xdrs, &day)) return 0; if ( ! xdr_int(xdrs, &hr)) return 0; if ( ! xdr_int(xdrs, &mn)) return 0; if ( ! xdr_float(xdrs, &fsec)) return 0; if (xdrs->x_op == XDR_DECODE) { sec = (int) floor(fsec); usec = (int) floor((fsec-sec)*1000000+0.5); if (usec==1000000) { sec += 1; usec = 0; } t->set(yr, mo, day, hr, mn, sec, usec); } return 1; }
/* load up two integers and a string using xdr, then ship them */ int main(int argc, char* argv[]) { int sock; int test_number_a; int test_number_b; float test_number_c; char test_string[512]; char buffer[1024]; XDR xdrobject; XDR *xdrstream = &xdrobject; /* Get a socket (UDP) */ sock = passiveUDP(get_port()); read(sock, buffer, sizeof(buffer)); close(sock); /* XDR a message */ xdrmem_create(xdrstream, buffer, sizeof(buffer), XDR_DECODE); xdr_int(xdrstream, &test_number_a); xdr_int(xdrstream, &test_number_b); xdr_float(xdrstream, &test_number_c); xdr_wrapstring(xdrstream, (char **)&test_string); // printf("(recv) string success? %i\n",xdr_wrapstring(xdrstream, &test_string)); printf("%d, %d, %f, %s\n", test_number_a, test_number_b, test_number_c, test_string); /* send the message */ xdr_destroy(xdrstream); return 0; }
/* load up two integers and a string using xdr, then ship them */ int main(int argc, char* argv[]) { int sock; int test_number_a; int test_number_b; float test_number_c; char *test_string = NULL; char buffer[80]; char *service = get_port(); XDR xdrobject; XDR *xdrstream = &xdrobject; /* Get a socket (UDP) */ sock = passiveUDP(service); read(sock, buffer, 80); close(sock); /* XDR a message */ xdrmem_create(xdrstream, buffer, 80, XDR_DECODE); xdr_int(xdrstream, &test_number_a); xdr_int(xdrstream, &test_number_b); xdr_float(xdrstream, &test_number_c); xdr_wrapstring(xdrstream, &test_string); printf("%d, %d, %f %s\n", test_number_a, test_number_b, test_number_c, test_string); /* send the message */ xdr_destroy(xdrstream); return 0; }
int xdr_dark(XDR *xdrs,struct dark_particle *p) { if (xdr_float(xdrs,&p->mass) != TRUE) return 0; if (xdr_float(xdrs,&p->pos[0]) != TRUE) return 0; if (xdr_float(xdrs,&p->pos[1]) != TRUE) return 0; if (xdr_float(xdrs,&p->pos[2]) != TRUE) return 0; if (xdr_float(xdrs,&p->vel[0]) != TRUE) return 0; if (xdr_float(xdrs,&p->vel[1]) != TRUE) return 0; if (xdr_float(xdrs,&p->vel[2]) != TRUE) return 0; if (xdr_float(xdrs,&p->eps) != TRUE) return 0; if (xdr_float(xdrs,&p->phi) != TRUE) return 0; return 1; }
static int xdr_r2f(XDR *xdrs,real *r,bool bRead) { #ifdef GMX_DOUBLE float f; int ret; if (!bRead) f = *r; ret = xdr_float(xdrs,&f); if (bRead) *r = f; return ret; #else return xdr_float(xdrs,(float *)r); #endif }
void F77_FUNC(xdrffloat,XDRFFLOAT)(int *xdrid, float *fp, int *ret) { xdr_fortran_lock(); *ret = xdr_float(xdridptr[*xdrid], fp); cnt += sizeof(float); xdr_fortran_unlock(); }
int ssioDataReduced(SSIO *ssio,SSRDATA *data) { #ifdef SSIO_USE_MPI assert(0); /*DEBUG! reduced format not supported with MPI files yet */ #endif int i; assert(ssio != NULL && data != NULL); if (!xdr_float(&ssio->xdrs,&data->fMass)) return 1; if (!xdr_float(&ssio->xdrs,&data->fRadius)) return 1; for (i=0;i<N_DIM;i++) if (!xdr_float(&ssio->xdrs,&data->vPos[i])) return 1; if (!xdr_int(&ssio->xdrs,&data->iColor)) return 1; if (!xdr_int(&ssio->xdrs,&data->iOrgIdx)) return 1; return 0; }
int main() { /* This should only compile, not run, so set xd to NULL */ XDR *xd = NULL; float f; xdr_float(xd,&f); return 0; }
bool_t xdr_jobSetup (XDR *xdrs, struct jobSetup *jsetup, struct LSFHeader *hdr) { static char fname[]="xdr_jobSetup"; char *sp1, *sp2, *sp3; int jobArrId, jobArrElemId; if (xdrs->x_op == XDR_ENCODE) { jobId64To32(jsetup->jobId, &jobArrId, &jobArrElemId); } if (!(xdr_int(xdrs, &jobArrId) && xdr_int(xdrs, &jsetup->jStatus) && xdr_float(xdrs, &jsetup->cpuTime) && xdr_int(xdrs, &jsetup->w_status) && xdr_int(xdrs, &jsetup->reason) && xdr_int(xdrs, &jsetup->jobPid) && xdr_int(xdrs, &jsetup->jobPGid) && xdr_int(xdrs, &jsetup->execGid) && xdr_int(xdrs, &jsetup->execUid) && xdr_int(xdrs, &jsetup->execJobFlag))) { ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_int"); return (FALSE); } if (!xdr_arrayElement(xdrs, (char *) &jsetup->lsfRusage, hdr, xdr_lsfRusage)) return (FALSE); sp1 = jsetup->execUsername; sp2 = jsetup->execHome; sp3 = jsetup->execCwd; if (xdrs->x_op == XDR_DECODE) { sp1[0] = '\0'; sp2[0] = '\0'; sp3[0] = '\0'; } if (!(xdr_string(xdrs, &sp1, MAX_LSB_NAME_LEN) && xdr_string(xdrs, &sp2, MAXFILENAMELEN) && xdr_string(xdrs, &sp3, MAXFILENAMELEN))) { ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_string"); return (FALSE); } if (!xdr_int(xdrs, &jobArrElemId)) { return (FALSE); } if (xdrs->x_op == XDR_DECODE) { jobId32To64(&jsetup->jobId,jobArrId,jobArrElemId); } return (TRUE); }
static int xdr_r2f(XDR *xdrs, real *r, gmx_bool gmx_unused bRead) { #if GMX_DOUBLE float f; int ret; if (!bRead) { f = *r; } ret = xdr_float(xdrs, &f); if (bRead) { *r = f; } return ret; #else return xdr_float(xdrs, static_cast<float *>(r)); #endif }
bool_t xdr_rpc_loc_gnss_info_s_type (XDR *xdrs, rpc_loc_gnss_info_s_type *objp) { register int32_t *buf; if (!xdr_rpc_loc_gnss_info_valid_mask_type (xdrs, &objp->valid_mask)) return FALSE; if (!xdr_float (xdrs, &objp->position_dop)) return FALSE; if (!xdr_float (xdrs, &objp->horizontal_dop)) return FALSE; if (!xdr_float (xdrs, &objp->vertical_dop)) return FALSE; if (!xdr_rpc_boolean (xdrs, &objp->altitude_assumed)) return FALSE; if (!xdr_rpc_uint16 (xdrs, &objp->sv_count)) return FALSE; if (!xdr_array (xdrs, (char **)&objp->sv_list.sv_list_val, (u_int *) &objp->sv_list.sv_list_len, 80, sizeof (rpc_loc_sv_info_s_type), (xdrproc_t) xdr_rpc_loc_sv_info_s_type)) return FALSE; return TRUE; }
float f_print( XDR *xdrs, char *fmt ) { float ff; if( !xdr_float(xdrs, &ff) ) { fflush( stdout); exit(1); } printf( fmt, ff); return ff; }
static void convert_float(XDR * xdrs, char *null_buf, const FCELL * rast, int row, int n) { int i; for (i = 0; i < n; i++) { FCELL f; /* substitute embeded null vals by 0's */ if (Rast_is_f_null_value(&rast[i])) { f = 0.; null_buf[i] = 1; } else f = rast[i]; if (!xdr_float(xdrs, &f)) G_fatal_error(_("xdr_float failed for index %d of row %d"), i, row); } }
// filtre pour le type matrice bool_t xdr_mat(XDR *xdrs, matrice **m) { unsigned int i, j, n ; float *c ; matrice *mat ; switch (xdrs->x_op) { case XDR_ENCODE : fprintf(stderr,"xdr_mat : ENCODE(%d)\n", xdrs->x_op) ; break ; case XDR_DECODE : fprintf(stderr,"xdr_mat : DECODE(%d)\n", xdrs->x_op) ; break ; case XDR_FREE : fprintf(stderr,"xdr_mat : FREE(%d)\n", xdrs->x_op) ; break ; default : fprintf(stderr,"xdr_mat : default(%d)\n", xdrs->x_op) ; break ; } // encodage => encoder n if (xdrs->x_op == XDR_ENCODE) { mat = *m ; n = mat->n ; if (!xdr_u_int(xdrs, &n)) return FALSE ; } else // décodage => décoder n et allouer la matrice if (xdrs->x_op == XDR_DECODE) { if (!xdr_u_int(xdrs, &n)) return FALSE ; mat = malloc_mat(n) ; *m = mat ; } c = mat->tab ; for (i = 0; i < n; ++i) for (j = 0; j < n; ++j) if (!xdr_float(xdrs, c++)) return FALSE ; return TRUE ; }
bool_t xdr_jobSpecs (XDR *xdrs, struct jobSpecs *jobSpecs, struct LSFHeader *hdr) { static char fname[] = "xdr_jobSpecs"; char *sp[15]; char *pTemp; int i, nLimits; int jobArrId, jobArrElemId; LS_LONG_INT tmpJobId; if (xdrs->x_op == XDR_DECODE) { jobSpecs->numToHosts = 0; jobSpecs->toHosts = NULL; jobSpecs->nxf = 0; jobSpecs->xf = NULL; jobSpecs->numEnv = 0; jobSpecs->env = NULL; jobSpecs->eexec.len = 0; jobSpecs->eexec.data = NULL; jobSpecs->loginShell = NULL; jobSpecs->schedHostType= NULL; jobSpecs->execHosts = NULL; } if (xdrs->x_op == XDR_FREE) { for(i=0; i < jobSpecs->numToHosts; i++) { FREEUP(jobSpecs->toHosts[i]); } FREEUP(jobSpecs->toHosts); for(i=0; i < jobSpecs->numEnv; i++) FREEUP(jobSpecs->env[i]); FREEUP(jobSpecs->env); FREEUP(jobSpecs->xf); FREEUP(jobSpecs->loginShell); FREEUP(jobSpecs->schedHostType); FREEUP(jobSpecs->execHosts); if (!xdr_thresholds(xdrs, jobSpecs) || !xdr_lenData(xdrs, &jobSpecs->eexec)) return(FALSE); return(TRUE); } if (xdrs->x_op == XDR_ENCODE) { jobId64To32(jobSpecs->jobId, &jobArrId, &jobArrElemId); } if (!xdr_int(xdrs, &jobArrId)) { ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname, "xdr_int", "jobId"); return(FALSE); } if (!(xdr_int(xdrs, &jobSpecs->userId) && xdr_int(xdrs, &jobSpecs->options) && xdr_short(xdrs, &jobSpecs->nice) && xdr_int(xdrs, &jobSpecs->priority) && xdr_int(xdrs, &jobSpecs->chkSig) && xdr_int(xdrs, &jobSpecs->actPid) && xdr_time_t(xdrs, &jobSpecs->chkPeriod) && xdr_time_t(xdrs, &jobSpecs->migThresh) && xdr_time_t(xdrs, &jobSpecs->lastSSuspTime) && xdr_float(xdrs, &jobSpecs->lastCpuTime))) { ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname, "xdr_int", "userId"); return(FALSE); } nLimits = LSF_RLIM_NLIMITS; tmpJobId = jobArrId; if (!xdr_int(xdrs, &nLimits)) { ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname, lsb_jobid2str(tmpJobId), "xdr_int", "nLimits"); return(FALSE); } for (i = 0; i < nLimits && i < LSF_RLIM_NLIMITS; i++) { if(!xdr_lsfLimit(xdrs, &jobSpecs->lsfLimits[i], hdr)) { ls_syslog(LOG_ERR, I18N_JOB_FAIL_S, fname, lsb_jobid2str(tmpJobId), "xdr_lsfLimit"); return(FALSE); } } if (nLimits > LSF_RLIM_NLIMITS) { for (i=LSF_RLIM_NLIMITS; i<nLimits; i++) { struct lsfLimit lsfLimit; if (!xdr_lsfLimit(xdrs, &lsfLimit, hdr)) { ls_syslog(LOG_ERR, I18N_JOB_FAIL_S, fname, lsb_jobid2str(tmpJobId), "xdr_lsfLimit"); return(FALSE); } } } if (!(xdr_int(xdrs, &jobSpecs->jStatus) && xdr_int(xdrs, &jobSpecs->reasons) && xdr_int(xdrs, &jobSpecs->subreasons) && xdr_time_t(xdrs, &jobSpecs->termTime) && xdr_time_t(xdrs, &jobSpecs->startTime) && xdr_int(xdrs, &jobSpecs->runTime) && xdr_time_t(xdrs, &jobSpecs->submitTime) && xdr_int(xdrs, &jobSpecs->jobPid) && xdr_int(xdrs, &jobSpecs->jobPGid) && xdr_int(xdrs, &jobSpecs->restartPid) && xdr_int(xdrs, &jobSpecs->sigValue) && xdr_int(xdrs, &jobSpecs->umask) && xdr_int(xdrs, &jobSpecs->jAttrib))) { ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname, lsb_jobid2str(tmpJobId), "xdr_int", "jStatus"); return(FALSE); } sp[0] = jobSpecs->jobFile; sp[1] = jobSpecs->inFile; sp[2] = jobSpecs->outFile; sp[3] = jobSpecs->errFile; sp[4] = jobSpecs->chkpntDir; sp[5] = jobSpecs->cwd; sp[6] = jobSpecs->subHomeDir; sp[7] = jobSpecs->command; sp[8] = jobSpecs->jobName; sp[9] = jobSpecs->preExecCmd; sp[10] = jobSpecs->fromHost; sp[11] = jobSpecs->resReq; if (xdrs->x_op == XDR_DECODE) for (i = 0; i < 11; i++) sp[i][0] = '\0'; if (!(xdr_string(xdrs, &sp[0], MAXFILENAMELEN) && xdr_string(xdrs, &sp[1], MAXFILENAMELEN) && xdr_string(xdrs, &sp[2], MAXFILENAMELEN) && xdr_string(xdrs, &sp[3], MAXFILENAMELEN) && xdr_string(xdrs, &sp[4], MAXFILENAMELEN) && xdr_string(xdrs, &sp[5], MAXFILENAMELEN) && xdr_string(xdrs, &sp[6], MAXFILENAMELEN) && xdr_string(xdrs, &sp[7], MAXLINELEN) && xdr_string(xdrs, &sp[8], MAXLINELEN) && xdr_string(xdrs, &sp[9], MAXLINELEN) && xdr_string(xdrs, &sp[10], MAXHOSTNAMELEN))) { ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname, lsb_jobid2str(tmpJobId), "xdr_int", "jobFile"); return(FALSE); } if (xdrs->x_op == XDR_DECODE) sp[11][0] = '\0'; if (!xdr_string(xdrs, &sp[11], MAXLINELEN)) { ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname, lsb_jobid2str(tmpJobId), "xdr_int", "jobFile"); return(FALSE); } sp[12] = jobSpecs->queue; sp[13] = jobSpecs->windows; sp[14] = jobSpecs->userName; if (xdrs->x_op == XDR_DECODE) for (i = 12; i < 15; i++) sp[i][0] = '\0'; if (!(xdr_string(xdrs, &sp[12], MAXFILENAMELEN) && xdr_string(xdrs, &sp[13], MAXLINELEN) && xdr_string(xdrs, &sp[14], MAX_LSB_NAME_LEN))) { ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname, lsb_jobid2str(tmpJobId), "xdr_int", "jobFile"); return(FALSE); } if (!xdr_int(xdrs, &jobSpecs->numToHosts)) { ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname, lsb_jobid2str(tmpJobId), "xdr_int", "numToHosts"); return(FALSE); } if (xdrs->x_op == XDR_DECODE && jobSpecs->numToHosts) { jobSpecs->toHosts = (char **) my_calloc(jobSpecs->numToHosts, sizeof (char *), fname); } for (i = 0; i < jobSpecs->numToHosts; i++) { if (!xdr_var_string(xdrs, &jobSpecs->toHosts[i])) { ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname, lsb_jobid2str(tmpJobId), "xdr_var_string", "toHosts"); return(FALSE); } } if (!xdr_thresholds(xdrs, jobSpecs)) ls_syslog(LOG_ERR, I18N_JOB_FAIL_S, fname, lsb_jobid2str(tmpJobId), "xdr_thresholds"); if (!xdr_int(xdrs, &jobSpecs->nxf)) { ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname, lsb_jobid2str(tmpJobId), "xdr_int", "nxf"); return(FALSE); } if (xdrs->x_op == XDR_DECODE && jobSpecs->nxf > 0) { jobSpecs->xf = (struct xFile *) my_calloc(jobSpecs->nxf, sizeof(struct xFile), fname); } for (i = 0; i < jobSpecs->nxf; i++) { if (!xdr_arrayElement(xdrs, (char *) &(jobSpecs->xf[i]), hdr, xdr_xFile)) { ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname, lsb_jobid2str(tmpJobId), "xdr_arrayElement", "xf"); return(FALSE); } } sp[0] = jobSpecs->mailUser; sp[1] = jobSpecs->clusterName; sp[2] = jobSpecs->projectName; sp[3] = jobSpecs->preCmd; sp[4] = jobSpecs->postCmd; sp[5] = jobSpecs->execCwd; sp[6] = jobSpecs->execHome; sp[7] = jobSpecs->requeueEValues; if (xdrs->x_op == XDR_DECODE) { for(i=0; i < 8; i++) sp[i][0]= '\0'; } if (!(xdr_string(xdrs, &sp[0], MAXLINELEN) && xdr_string(xdrs, &sp[1], MAX_LSB_NAME_LEN) && xdr_string(xdrs, &sp[2], MAX_LSB_NAME_LEN) && xdr_string(xdrs, &sp[3], MAXLINELEN) && xdr_string(xdrs, &sp[4], MAXLINELEN) && xdr_string(xdrs, &sp[5], MAXFILENAMELEN) && xdr_string(xdrs, &sp[6], MAXFILENAMELEN) && xdr_string(xdrs, &sp[7], MAXLINELEN) && xdr_int(xdrs, &jobSpecs->execUid) && xdr_int(xdrs, &jobSpecs->maxNumProcessors) && xdr_int(xdrs, &jobSpecs->numEnv))) return(FALSE); if (xdrs->x_op == XDR_DECODE && jobSpecs->numEnv) { jobSpecs->env = (char **) my_calloc(jobSpecs->numEnv, sizeof (char *), fname); } for (i = 0; i < jobSpecs->numEnv; i++) { if (!xdr_var_string(xdrs, &jobSpecs->env[i])) return(FALSE); } if (!xdr_lenData(xdrs, &jobSpecs->eexec)) return (FALSE); if (!xdr_int(xdrs, &jobSpecs->niosPort)) return (FALSE); sp[0] = jobSpecs->resumeCond; sp[1] = jobSpecs->stopCond; sp[2] = jobSpecs->suspendActCmd; sp[3] = jobSpecs->resumeActCmd; sp[4] = jobSpecs->terminateActCmd; if (xdrs->x_op == XDR_DECODE) { sp[0][0] = '\0'; sp[1][0] = '\0'; } if (!(xdr_string(xdrs, &sp[0], MAXLINELEN)) || !(xdr_string(xdrs, &sp[1], MAXLINELEN))) return (FALSE); if (xdrs->x_op == XDR_DECODE) { for ( i = 2; i < 5; i++) sp[i][0] = '\0'; } for ( i = 2; i < 5; i++) if (!(xdr_string(xdrs, &sp[i], MAXLINELEN))) return(FALSE); for (i = 0; i <LSB_SIG_NUM; i++) if (!(xdr_int(xdrs, &jobSpecs->sigMap[i]))) return(FALSE); if (!(xdr_int(xdrs, &jobSpecs->actValue))) return (FALSE); if (!xdr_var_string(xdrs, &jobSpecs->loginShell)) return (FALSE); if (!xdr_var_string(xdrs, &jobSpecs->schedHostType)) return (FALSE); if (!xdr_var_string(xdrs, &jobSpecs->execHosts)) return (FALSE); if (!xdr_int(xdrs, &jobSpecs->options2)) { return(FALSE); } pTemp = jobSpecs->jobSpoolDir; if(!( xdr_string(xdrs, &pTemp, MAXPATHLEN))) { ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname, "xdr_string", "jobSpoolDir"); return(FALSE); } if (!(xdr_int(xdrs, &jobArrElemId))) { return (FALSE); } if (xdrs->x_op == XDR_DECODE) { jobId32To64(&jobSpecs->jobId,jobArrId,jobArrElemId); } sp[0] = jobSpecs->inFileSpool; sp[1] = jobSpecs->commandSpool; if (!(xdr_string(xdrs, &sp[0], MAXFILENAMELEN))) { ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname, "xdr_string", "inFileSpool"); return (FALSE); } if (!(xdr_string(xdrs, &sp[1], MAXFILENAMELEN))) { ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname, "xdr_string", "commandSpool"); return (FALSE); } if (!(xdr_int(xdrs, &jobSpecs->userPriority))) { ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname, "xdr_int", "userPriority"); return (FALSE); } sp[0] = jobSpecs->execUsername; if (!(xdr_string(xdrs, &sp[0], MAX_LSB_NAME_LEN))) { ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname, "xdr_string", "execUsername"); return (FALSE); } sp[0] = jobSpecs->prepostUsername; if (!(xdr_string(xdrs, &sp[0], MAX_LSB_NAME_LEN))) { ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname, "xdr_string", "prepostUsername"); return (FALSE); } return(TRUE); }