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);
}
