int DLL_DECL Cns_deleteclass(char *server, int classid, char *class_name) { int c; char func[16]; gid_t gid; int msglen; char *q; char *sbp; char sendbuf[REQBUFSZ]; struct Cns_api_thread_info *thip; uid_t uid; strcpy (func, "Cns_deleteclass"); if (Cns_apiinit (&thip)) return (-1); uid = geteuid(); gid = getegid(); #if defined(_WIN32) if (uid < 0 || gid < 0) { Cns_errmsg (func, NS053); serrno = SENOMAPFND; return (-1); } #endif /* Build request header */ sbp = sendbuf; marshall_LONG (sbp, CNS_MAGIC); marshall_LONG (sbp, CNS_DELCLASS); q = sbp; /* save pointer. The next field will be updated */ msglen = 3 * LONGSIZE; marshall_LONG (sbp, msglen); /* Build request body */ marshall_LONG (sbp, uid); marshall_LONG (sbp, gid); marshall_LONG (sbp, classid); if (class_name) { marshall_STRING (sbp, class_name); } else { marshall_STRING (sbp, ""); } msglen = sbp - sendbuf; marshall_LONG (q, msglen); /* update length field */ c = send2nsd (NULL, server, sendbuf, msglen, NULL, 0); if (c && serrno == SENAMETOOLONG) serrno = ENAMETOOLONG; return (c); }
struct Cns_direnrep DLL_DECL * Cns_readdirxr(Cns_DIR *dirp, char *se) { int c; int direntsz; struct Cns_direnrep *dp; char func[16]; int getattr = 5; gid_t gid; int i; struct Cns_rep_info *ir; int msglen; int n; int nbentries; char *q; char *rbp; struct Cns_rep_info *rep_entries; char repbuf[DIRBUFSZ+4]; char *sbp; char sendbuf[REQBUFSZ]; uid_t uid; strcpy (func, "Cns_readdirxr"); uid = geteuid(); gid = getegid(); #if defined(_WIN32) if (uid < 0 || gid < 0) { Cns_errmsg (func, NS053); serrno = SENOMAPFND; return (NULL); } #endif if (! dirp) { serrno = EFAULT; return (NULL); } if (se && strlen (se) > CA_MAXHOSTNAMELEN) { serrno = EINVAL; return (NULL); } /* compute size of client machine Cns_direnrep structure excluding d_name */ dp = (struct Cns_direnrep *) dirp->dd_buf; direntsz = &dp->d_name[0] - (char *) dp; if (dirp->dd_size == 0) { /* no data in the cache */ if (dirp->replicas) { /* free previous replica information */ ir = (struct Cns_rep_info *) dirp->replicas; for (i = 0; i < dirp->nbreplicas; i++) { free (ir->host); free (ir->sfn); ir++; } free (dirp->replicas); dirp->nbreplicas = 0; dirp->replicas = NULL; } if (dirp->eod) return (NULL); /* Build request header */ sbp = sendbuf; marshall_LONG (sbp, CNS_MAGIC); marshall_LONG (sbp, CNS_READDIR); q = sbp; /* save pointer. The next field will be updated */ msglen = 3 * LONGSIZE; marshall_LONG (sbp, msglen); /* Build request body */ marshall_LONG (sbp, uid); marshall_LONG (sbp, gid); marshall_WORD (sbp, getattr); marshall_WORD (sbp, direntsz); marshall_HYPER (sbp, dirp->fileid); marshall_WORD (sbp, dirp->bod); if (se) { marshall_STRING (sbp, se); } else { marshall_STRING (sbp, ""); } msglen = sbp - sendbuf; marshall_LONG (q, msglen); /* update length field */ c = send2nsdx (&dirp->dd_fd, NULL, sendbuf, msglen, repbuf, sizeof(repbuf), (void **) &dirp->replicas, &dirp->nbreplicas); if (c < 0) return (NULL); rbp = repbuf; unmarshall_WORD (rbp, nbentries); if (nbentries == 0) return (NULL); /* end of directory */ /* unmarshall reply into the Cns_direnrep structures */ dp = (struct Cns_direnrep *) dirp->dd_buf; i = 0; rep_entries = (struct Cns_rep_info *) dirp->replicas; while (nbentries--) { unmarshall_HYPER (rbp, dp->fileid); unmarshall_STRING (rbp, dp->guid); unmarshall_WORD (rbp, dp->filemode); unmarshall_HYPER (rbp, dp->filesize); dp->nbreplicas = 0; dp->rep = NULL; for ( ; i < dirp->nbreplicas; i++) { if (dp->fileid != (rep_entries+i)->fileid) break; dp->nbreplicas++; if (dp->nbreplicas == 1) dp->rep = rep_entries + i; } unmarshall_STRING (rbp, dp->d_name); dp->d_reclen = ((direntsz + strlen (dp->d_name) + 8) / 8) * 8; dp = (struct Cns_direnrep *) ((char *) dp + dp->d_reclen); } dirp->bod = 0; unmarshall_WORD (rbp, dirp->eod); dirp->dd_size = (char *) dp - dirp->dd_buf; } dp = (struct Cns_direnrep *) (dirp->dd_buf + dirp->dd_loc); dirp->dd_loc += dp->d_reclen; if (dirp->dd_loc >= dirp->dd_size) { /* must refill next time */ dirp->dd_loc = 0; dirp->dd_size = 0; } return (dp); }
int DLL_DECL Cns_setrtype(const char *sfn, const char type) { int c; char func[16]; gid_t gid; int msglen; char *q; char *sbp; char sendbuf[REQBUFSZ]; struct Cns_api_thread_info *thip; uid_t uid; u_signed64 zero = 0; strcpy (func, "Cns_setrtype"); if (Cns_apiinit (&thip)) return (-1); uid = getuid(); gid = getgid(); #if defined(_WIN32) if (uid < 0 || gid < 0) { Cns_errmsg (func, NS053); serrno = SENOMAPFND; return (-1); } #endif if (! sfn) { serrno = EFAULT; return (-1); } if (strlen (sfn) > CA_MAXSFNLEN) { serrno = ENAMETOOLONG; return (-1); } /* Build request header */ sbp = sendbuf; marshall_LONG (sbp, CNS_MAGIC); marshall_LONG (sbp, CNS_SETRTYPE); q = sbp; /* save pointer. The next field will be updated */ msglen = 3 * LONGSIZE; marshall_LONG (sbp, msglen); /* Build request body */ marshall_LONG (sbp, uid); marshall_LONG (sbp, gid); marshall_STRING (sbp, sfn); marshall_BYTE (sbp, type); msglen = sbp - sendbuf; marshall_LONG (q, msglen); /* update length field */ c = send2nsd (NULL, NULL, sendbuf, msglen, NULL, 0); if (c && serrno == SENAMETOOLONG) serrno = ENAMETOOLONG; return (c); }
int DLL_DECL Cns_setacl(const char *path, int nentries, struct Cns_acl *acl) { char *actual_path; int c; char func[16]; gid_t gid; int i; int msglen; char *q; char *sbp; char sendbuf[REQBUFSZ]; char server[CA_MAXHOSTNAMELEN+1]; struct Cns_api_thread_info *thip; uid_t uid; strcpy (func, "Cns_setacl"); if (Cns_apiinit (&thip)) return (-1); uid = getuid(); gid = getgid(); #if defined(_WIN32) if (uid < 0 || gid < 0) { Cns_errmsg (func, NS053); serrno = SENOMAPFND; return (-1); } #endif if (! path || ! acl) { serrno = EFAULT; return (-1); } if (strlen (path) > CA_MAXPATHLEN) { serrno = ENAMETOOLONG; return (-1); } if (nentries <= 0 || nentries > CA_MAXACLENTRIES) { serrno = EINVAL; return (-1); } if (Cns_selectsrvr (path, thip->server, server, &actual_path)) return (-1); /* Build request header */ sbp = sendbuf; marshall_LONG (sbp, CNS_MAGIC); marshall_LONG (sbp, CNS_SETACL); q = sbp; /* save pointer. The next field will be updated */ msglen = 3 * LONGSIZE; marshall_LONG (sbp, msglen); /* Build request body */ marshall_LONG (sbp, uid); marshall_LONG (sbp, gid); marshall_HYPER (sbp, thip->cwd); marshall_STRING (sbp, actual_path); marshall_WORD (sbp, nentries); for (i = 0; i < nentries; i++) { marshall_BYTE (sbp, acl->a_type); marshall_LONG (sbp, acl->a_id); marshall_BYTE (sbp, acl->a_perm); acl++; } msglen = sbp - sendbuf; marshall_LONG (q, msglen); /* update length field */ c = send2nsd (NULL, server, sendbuf, msglen, NULL, 0); if (c && serrno == SENAMETOOLONG) serrno = ENAMETOOLONG; return (c); }
int DLL_DECL Cns_modreplicax(const char *sfn, const char *setname, const char *poolname, const char *server, const char *fs, const char r_type) { int c; int extended = 0; char func[16]; gid_t gid; int msglen; char *q; char *sbp; char sendbuf[REQBUFSZ]; struct Cns_api_thread_info *thip; uid_t uid; u_signed64 zero = 0; strcpy (func, "Cns_modreplica"); if (Cns_apiinit (&thip)) return (-1); uid = getuid(); gid = getgid(); #if defined(_WIN32) if (uid < 0 || gid < 0) { Cns_errmsg (func, NS053); serrno = SENOMAPFND; return (-1); } #endif if (! sfn) { serrno = EFAULT; return (-1); } if (strlen (sfn) > CA_MAXSFNLEN) { serrno = ENAMETOOLONG; return (-1); } if ((setname && strlen (setname) > 36) || (poolname && strlen (poolname) > CA_MAXPOOLNAMELEN) || (server && strlen (server) > CA_MAXHOSTNAMELEN)) { serrno = EINVAL; return (-1); } /* Build request header */ if (r_type || (fs && strlen (fs) > 0)) extended = 1; sbp = sendbuf; marshall_LONG (sbp, CNS_MAGIC); marshall_LONG (sbp, (extended ? CNS_MODREPLICAX : CNS_MODREPLICA)); q = sbp; /* save pointer. The next field will be updated */ msglen = 3 * LONGSIZE; marshall_LONG (sbp, msglen); /* Build request body */ marshall_LONG (sbp, uid); marshall_LONG (sbp, gid); marshall_STRING (sbp, sfn); if (setname) { marshall_STRING (sbp, setname); } else { marshall_STRING (sbp, ""); } if (poolname) { marshall_STRING (sbp, poolname); } else { marshall_STRING (sbp, ""); } if (server) { marshall_STRING (sbp, server); } else { marshall_STRING (sbp, ""); } if (extended) { if (fs) { marshall_STRING (sbp, fs); } else { marshall_STRING (sbp, ""); } marshall_BYTE (sbp, r_type); } msglen = sbp - sendbuf; marshall_LONG (q, msglen); /* update length field */ c = send2nsd (NULL, NULL, sendbuf, msglen, NULL, 0); if (c && serrno == SENAMETOOLONG) serrno = ENAMETOOLONG; return (c); }
int DLL_DECL Cns_du(const char *path, int Lflag, u_signed64 *nbbytes, u_signed64 *nbentries) { char *actual_path; int c; char func[16]; gid_t gid; int msglen; u_signed64 n; char *q; char *rbp; char repbuf[16]; char *sbp; char sendbuf[REQBUFSZ]; char server[CA_MAXHOSTNAMELEN+1]; struct Cns_api_thread_info *thip; uid_t uid; strcpy (func, "Cns_du"); if (Cns_apiinit (&thip)) return (-1); uid = geteuid(); gid = getegid(); #if defined(_WIN32) if (uid < 0 || gid < 0) { Cns_errmsg (func, NS053); serrno = SENOMAPFND; return (-1); } #endif if (! path) { serrno = EFAULT; return (-1); } if (strlen (path) > CA_MAXPATHLEN) { serrno = ENAMETOOLONG; return (-1); } if (Cns_selectsrvr (path, thip->server, server, &actual_path)) return (-1); /* Build request header */ sbp = sendbuf; marshall_LONG (sbp, CNS_MAGIC); marshall_LONG (sbp, CNS_DU); q = sbp; /* save pointer. The next field will be updated */ msglen = 3 * LONGSIZE; marshall_LONG (sbp, msglen); /* Build request body */ marshall_LONG (sbp, uid); marshall_LONG (sbp, gid); marshall_HYPER (sbp, thip->cwd); marshall_STRING (sbp, actual_path); marshall_WORD (sbp, Lflag); msglen = sbp - sendbuf; marshall_LONG (q, msglen); /* update length field */ c = send2nsd (NULL, server, sendbuf, msglen, repbuf, sizeof(repbuf)); if (c == 0) { rbp = repbuf; unmarshall_HYPER (rbp, n); if (nbbytes) *nbbytes = n; unmarshall_HYPER (rbp, n); if (nbentries) *nbentries = n; } if (c && serrno == SENAMETOOLONG) serrno = ENAMETOOLONG; return (c); }
int DLL_DECL Cns_delfilesbyguid(int nbguids, const char **guids, int force, int *nbstatuses, int **statuses) { int argtype = 0; int c; char func[19]; gid_t gid; int i; int msglen; char *q; char *rbp; char repbuf[4]; char *sbp; char *sendbuf; struct Cns_api_thread_info *thip; uid_t uid; strcpy (func, "Cns_delfilesbyguid"); if (Cns_apiinit (&thip)) return (-1); uid = geteuid(); gid = getegid(); #if defined(_WIN32) if (uid < 0 || gid < 0) { Cns_errmsg (func, NS053); serrno = SENOMAPFND; return (-1); } #endif if (nbguids <= 0) { serrno = EINVAL; return (-1); } if (! guids || ! nbstatuses || ! statuses) { serrno = EFAULT; return (-1); } /* Compute size of send buffer */ msglen = 5 * LONGSIZE; msglen += WORDSIZE; msglen += WORDSIZE; msglen += LONGSIZE; for (i = 0; i < nbguids; i++) { msglen += strlen (guids[i]) + 1; } /* Allocate send buffer */ if ((sendbuf = malloc (msglen)) == NULL) { serrno = ENOMEM; return (-1); } /* Build request header */ sbp = sendbuf; marshall_LONG (sbp, CNS_MAGIC); marshall_LONG (sbp, CNS_DELFILES); q = sbp; /* save pointer. The next field will be updated */ msglen = 3 * LONGSIZE; marshall_LONG (sbp, msglen); /* Build request body */ marshall_LONG (sbp, uid); marshall_LONG (sbp, gid); marshall_WORD (sbp, argtype); marshall_WORD (sbp, force); marshall_LONG (sbp, nbguids); for (i = 0; i < nbguids; i++) { marshall_STRING (sbp, guids[i]); } msglen = sbp - sendbuf; marshall_LONG (q, msglen); /* update length field */ c = send2nsdx (NULL, NULL, sendbuf, msglen, repbuf, sizeof(repbuf), (void **)statuses, nbstatuses); free (sendbuf); if (c == 0) { rbp = repbuf; unmarshall_LONG (rbp, *nbstatuses); if (*nbstatuses == 0) { *statuses = NULL; return (0); } } return (c); }
int DLL_DECL Cns_statr(const char *sfn, struct Cns_filestatg *statbuf) { int c, n; char func[16]; gid_t gid; int msglen; char *q; char *rbp; char repbuf[132]; char *sbp; char sendbuf[REQBUFSZ]; struct Cns_api_thread_info *thip; uid_t uid; strcpy (func, "Cns_statr"); if (Cns_apiinit (&thip)) return (-1); uid = geteuid(); gid = getegid(); #if defined(_WIN32) if (uid < 0 || gid < 0) { Cns_errmsg (func, NS053); serrno = SENOMAPFND; return (-1); } #endif if (! sfn || ! statbuf) { serrno = EFAULT; return (-1); } if (strlen (sfn) > CA_MAXSFNLEN) { serrno = ENAMETOOLONG; return (-1); } /* Build request header */ sbp = sendbuf; marshall_LONG (sbp, CNS_MAGIC); marshall_LONG (sbp, CNS_STATR); q = sbp; /* save pointer. The next field will be updated */ msglen = 3 * LONGSIZE; marshall_LONG (sbp, msglen); /* Build request body */ marshall_LONG (sbp, uid); marshall_LONG (sbp, gid); marshall_STRING (sbp, sfn); msglen = sbp - sendbuf; marshall_LONG (q, msglen); /* update length field */ c = send2nsd (NULL, NULL, sendbuf, msglen, repbuf, sizeof(repbuf)); if (c == 0) { rbp = repbuf; unmarshall_HYPER (rbp, statbuf->fileid); unmarshall_STRING (rbp, statbuf->guid); unmarshall_WORD (rbp, statbuf->filemode); unmarshall_LONG (rbp, statbuf->nlink); unmarshall_LONG (rbp, statbuf->uid); unmarshall_LONG (rbp, statbuf->gid); unmarshall_HYPER (rbp, statbuf->filesize); unmarshall_TIME_T (rbp, statbuf->atime); unmarshall_TIME_T (rbp, statbuf->mtime); unmarshall_TIME_T (rbp, statbuf->ctime); unmarshall_WORD (rbp, statbuf->fileclass); unmarshall_BYTE (rbp, statbuf->status); unmarshall_STRING (rbp, statbuf->csumtype); unmarshall_STRING (rbp, statbuf->csumvalue); } if (c && serrno == SENAMETOOLONG) serrno = ENAMETOOLONG; return (c); }
int DLL_DECL Cns_lstat(const char *path, struct Cns_filestat *statbuf) { char *actual_path; int c, n; char func[16]; gid_t gid; int msglen; char *q; char *rbp; char repbuf[57]; char *sbp; char sendbuf[REQBUFSZ]; char server[CA_MAXHOSTNAMELEN+1]; struct Cns_api_thread_info *thip; uid_t uid; u_signed64 zero = 0; strcpy (func, "Cns_lstat"); if (Cns_apiinit (&thip)) return (-1); uid = geteuid(); gid = getegid(); #if defined(_WIN32) if (uid < 0 || gid < 0) { Cns_errmsg (func, NS053); serrno = SENOMAPFND; return (-1); } #endif if (! path || ! statbuf) { serrno = EFAULT; return (-1); } if (strlen (path) > CA_MAXPATHLEN) { serrno = ENAMETOOLONG; return (-1); } if (Cns_selectsrvr (path, thip->server, server, &actual_path)) return (-1); /* Build request header */ sbp = sendbuf; marshall_LONG (sbp, CNS_MAGIC2); marshall_LONG (sbp, CNS_LSTAT); q = sbp; /* save pointer. The next field will be updated */ msglen = 3 * LONGSIZE; marshall_LONG (sbp, msglen); /* Build request body */ marshall_LONG (sbp, uid); marshall_LONG (sbp, gid); marshall_HYPER (sbp, thip->cwd); marshall_HYPER (sbp, zero); marshall_STRING (sbp, actual_path); msglen = sbp - sendbuf; marshall_LONG (q, msglen); /* update length field */ c = send2nsd (NULL, server, sendbuf, msglen, repbuf, sizeof(repbuf)); if (c == 0) { rbp = repbuf; unmarshall_HYPER (rbp, statbuf->fileid); unmarshall_WORD (rbp, statbuf->filemode); unmarshall_LONG (rbp, statbuf->nlink); unmarshall_LONG (rbp, statbuf->uid); unmarshall_LONG (rbp, statbuf->gid); unmarshall_HYPER (rbp, statbuf->filesize); unmarshall_TIME_T (rbp, statbuf->atime); unmarshall_TIME_T (rbp, statbuf->mtime); unmarshall_TIME_T (rbp, statbuf->ctime); unmarshall_WORD (rbp, statbuf->fileclass); unmarshall_BYTE (rbp, statbuf->status); } if (c && serrno == SENAMETOOLONG) serrno = ENAMETOOLONG; return (c); }
struct Cns_linkinfo * Cns_listlinks(const char *path, const char *guid, int flags, Cns_list *listp) { char *actual_path; int bol = 0; int c; char func[16]; gid_t gid; int listentsz = sizeof(struct Cns_linkinfo); struct Cns_linkinfo *lp; int msglen; int nbentries; char *p; char *q; char *rbp; char repbuf[LISTBUFSZ+4]; char *sbp; char sendbuf[REQBUFSZ]; char server[CA_MAXHOSTNAMELEN+1]; struct Cns_api_thread_info *thip; uid_t uid; strcpy (func, "Cns_listlinks"); if (Cns_apiinit (&thip)) return (NULL); uid = geteuid(); gid = getegid(); #if defined(_WIN32) if (uid < 0 || gid < 0) { Cns_errmsg (func, NS053); serrno = SENOMAPFND; return (NULL); } #endif if ((! path && ! guid) || ! listp) { serrno = EFAULT; return (NULL); } if ((path && strlen (path) > CA_MAXPATHLEN) || (guid && strlen (guid) > CA_MAXGUIDLEN)) { serrno = ENAMETOOLONG; return (NULL); } if (path && Cns_selectsrvr (path, thip->server, server, &actual_path)) return (NULL); if (flags == CNS_LIST_BEGIN) { memset (listp, 0, sizeof(Cns_list)); listp->fd = -1; if ((listp->buf = malloc (LISTBUFSZ)) == NULL) { serrno = ENOMEM; return (NULL); } bol = 1; } if (listp->len == 0 && listp->eol /* all entries have been listed */ && flags != CNS_LIST_END) return (NULL); if (listp->buf == NULL) return (NULL); /* buffer has already been freed */ if (listp->len == 0 /* no data in the cache */ || flags == CNS_LIST_END) { /* Build request header */ sbp = sendbuf; marshall_LONG (sbp, CNS_MAGIC); if (flags == CNS_LIST_END) { marshall_LONG (sbp, CNS_ENDLIST); } else { marshall_LONG (sbp, CNS_LISTLINKS); } q = sbp; /* save pointer. The next field will be updated */ msglen = 3 * LONGSIZE; marshall_LONG (sbp, msglen); /* Build request body */ marshall_LONG (sbp, uid); marshall_LONG (sbp, gid); marshall_WORD (sbp, listentsz); marshall_HYPER (sbp, thip->cwd); if (path) { marshall_STRING (sbp, actual_path); } else { marshall_STRING (sbp, ""); } if (guid) { marshall_STRING (sbp, guid); } else { marshall_STRING (sbp, ""); } marshall_WORD (sbp, bol); msglen = sbp - sendbuf; marshall_LONG (q, msglen); /* update length field */ c = send2nsd (&listp->fd, path ? server : NULL, sendbuf, msglen, repbuf, sizeof(repbuf)); if (c < 0 || flags == CNS_LIST_END) { if (listp->buf) free (listp->buf); listp->buf = NULL; return (NULL); } rbp = repbuf; unmarshall_WORD (rbp, nbentries); if (nbentries == 0) return (NULL); /* end of list */ /* unmarshall reply into Cns_linkinfo structures */ lp = (struct Cns_linkinfo *) listp->buf; while (nbentries--) { unmarshall_STRING (rbp, lp->path); lp++; } unmarshall_WORD (rbp, listp->eol); listp->len = (char *) lp - listp->buf; } lp = (struct Cns_linkinfo *) (listp->buf + listp->offset); listp->offset += sizeof(struct Cns_linkinfo); if (listp->offset >= listp->len) { /* must refill next time */ listp->offset = 0; listp->len = 0; } return (lp); }
int DLL_DECL Cns_registerfiles(int nbfiles, struct Cns_filereg *files, int *nbstatuses, int **statuses) { int c; char func[18]; gid_t gid; int i; int msglen; char *q; char *rbp; char repbuf[4]; char *sbp; char *sendbuf; struct Cns_api_thread_info *thip; uid_t uid; strcpy (func, "Cns_registerfiles"); if (Cns_apiinit (&thip)) return (-1); uid = geteuid(); gid = getegid(); #if defined(_WIN32) if (uid < 0 || gid < 0) { Cns_errmsg (func, NS053); serrno = SENOMAPFND; return (-1); } #endif if (nbfiles <= 0) { serrno = EINVAL; return (-1); } if (! files || ! nbstatuses || ! statuses) { serrno = EFAULT; return (-1); } /* Compute size of send buffer */ msglen = 5 * LONGSIZE; msglen += WORDSIZE; msglen += HYPERSIZE; msglen += LONGSIZE; for (i = 0; i < nbfiles; i++) { msglen += strlen ((files+i)->lfn) + 1; if ((files+i)->guid) { msglen += strlen ((files+i)->guid) + 1; } else { msglen++; } msglen += LONGSIZE; msglen += HYPERSIZE; if ((files+i)->csumtype) { msglen += strlen ((files+i)->csumtype) + 1; } else { msglen++; } if ((files+i)->csumvalue) { msglen += strlen ((files+i)->csumvalue) + 1; } else { msglen++; } msglen += strlen ((files+i)->server) + 1; msglen += strlen ((files+i)->sfn) + 1; } /* Allocate send buffer */ if ((sendbuf = malloc (msglen)) == NULL) { serrno = ENOMEM; return (-1); } /* Build request header */ sbp = sendbuf; marshall_LONG (sbp, CNS_MAGIC); marshall_LONG (sbp, CNS_REGFILES); q = sbp; /* save pointer. The next field will be updated */ msglen = 3 * LONGSIZE; marshall_LONG (sbp, msglen); /* Build request body */ marshall_LONG (sbp, uid); marshall_LONG (sbp, gid); marshall_WORD (sbp, thip->mask); marshall_HYPER (sbp, thip->cwd); marshall_LONG (sbp, nbfiles); for (i = 0; i < nbfiles; i++) { marshall_STRING (sbp, (files+i)->lfn); if ((files+i)->guid) { marshall_STRING (sbp, (files+i)->guid); } else { marshall_STRING (sbp, ""); } marshall_LONG (sbp, (files+i)->mode); marshall_HYPER (sbp, (files+i)->size); if ((files+i)->guid) { marshall_STRING (sbp, (files+i)->csumtype); } else { marshall_STRING (sbp, ""); } if ((files+i)->guid) { marshall_STRING (sbp, (files+i)->csumvalue); } else { marshall_STRING (sbp, ""); } marshall_STRING (sbp, (files+i)->server); marshall_STRING (sbp, (files+i)->sfn); } msglen = sbp - sendbuf; marshall_LONG (q, msglen); /* update length field */ c = send2nsdx (NULL, NULL, sendbuf, msglen, repbuf, sizeof(repbuf), (void **)statuses, nbstatuses); free (sendbuf); if (c == 0) { rbp = repbuf; unmarshall_LONG (rbp, *nbstatuses); if (*nbstatuses == 0) { *statuses = NULL; return (0); } } return (c); }