int sc_struct::unpack_array_attr(sc_session *s,sc_addr tuple,sc_smart_addr arr[],sc_addr attrs[],int max_cnt,int min_cnt) { int i=0; for (;i<min_cnt;i++) arr[i] = find_attr(s,tuple,attrs[i]); for (;i<max_cnt;i++) if (!(arr[i] = find_attr(s,tuple,attrs[i]))) break; return i; }
std::vector<sc_smart_addr> sc_struct::unpack_vector_attr(sc_session *s,sc_addr tuple,sc_addr attrs[],int max_cnt,int min_cnt) { std::vector<sc_smart_addr> rv; rv.reserve(min_cnt); int i=0; for (;i<min_cnt;i++) rv.push_back(find_attr(s,tuple,attrs[i])); for (;i<max_cnt;i++) { sc_addr addr = find_attr(s,tuple,attrs[i]); if (!addr) break; rv.push_back(addr); } return rv; }
int status_attrib(svrattrl *pal, attribute_def *padef, attribute *pattr, int limit, int priv, pbs_list_head *phead, int *bad) { int index; int nth = 0; priv &= (ATR_DFLAG_RDACC | ATR_DFLAG_SvWR); /* user-client privilege */ resc_access_perm = priv; /* pass privilege to encode_resc() */ /* for each attribute asked for or for all attributes, add to reply */ if (pal) { /* client specified certain attributes */ while (pal) { ++nth; index = find_attr(padef, pal->al_name, limit); if (index < 0) { *bad = nth; return (-1); } if ((padef+index)->at_flags & priv) { svrcached(pattr+index, phead, padef+index); } pal = (svrattrl *)GET_NEXT(pal->al_link); } } else { /* non specified, return all readable attributes */ for (index = 0; index < limit; index++) { if ((padef+index)->at_flags & priv) { svrcached(pattr+index, phead, padef+index); } } } return (0); }
int read_service(xmlNode *list_node, service_t **dst) { int res = 0; xmlAttr *a; const char *a_val; xmlNode *n; int first_node; DEBUG_LOG("read_service(): called\n"); /* allocate memory and prepare empty node */ if (!dst) return -1; *dst = (service_t*)cds_malloc(sizeof(service_t)); if (!(*dst)) return -2; memset(*dst, 0, sizeof(service_t)); /* get attributes */ a = find_attr(list_node->properties, "uri"); if (a) { a_val = get_attr_value(a); if (a_val) (*dst)->uri = zt_strdup(a_val); } /* read child nodes */ n = list_node->children; first_node = 1; while (n) { if (n->type == XML_ELEMENT_NODE) { if (first_node) { /* element must be list or resource-list */ if (cmp_node(n, "list", rls_namespace) >= 0) { res = read_list(n, &(*dst)->content.list, 0); if ( (res == 0) && ((*dst)->content.list) ) { (*dst)->content_type = stc_list; } else return -1; } else if (cmp_node(n, "resource-list", rls_namespace) >= 0) { a_val = get_node_value(n); if (a_val) (*dst)->content.resource_list = zt_strdup(a_val); else (*dst)->content.resource_list = NULL; (*dst)->content_type = stc_resource_list; } else return -1; first_node = 0; } else { /* packages node */ if (cmp_node(n, "packages", rls_namespace) >= 0) { res = read_packages(n, &(*dst)->packages); } break; } } n = n->next; } return 0; }
void decode_attribute( svrattrl *pal, job **pjob) { int index; job *pj = *pjob; /* find the pbs_attribute definition based on the name */ index = find_attr(job_attr_def, pal->al_name, JOB_ATR_LAST); if (index < 0) index = JOB_ATR_UNKN; job_attr_def[index].at_free(&pj->ji_wattr[index]); job_attr_def[index].at_decode( &pj->ji_wattr[index], pal->al_name, pal->al_resc, pal->al_value, ATR_DFLAG_ACCESS); if (job_attr_def[index].at_action != NULL) job_attr_def[index].at_action(&pj->ji_wattr[index], pj, ATR_ACTION_RECOV); pj->ji_wattr[index].at_flags = pal->al_flags & ~ATR_VFLAG_MODIFY; }
static void check_style_attr (struct taginfo *tag, struct map_context *ctx) { int attrind; int raw_start; int raw_len; char *style = find_attr (tag, "style", &attrind); if (!style) return; /* raw pos and raw size include the quotes, skip them when they are present. */ raw_start = ATTR_POS (tag, attrind, ctx); raw_len = ATTR_SIZE (tag, attrind); if( *(char *)(ctx->text + raw_start) == '\'' || *(char *)(ctx->text + raw_start) == '"') { raw_start += 1; raw_len -= 2; } if(raw_len <= 0) return; get_urls_css (ctx, raw_start, raw_len); }
END_TEST START_TEST(test_three) { pbs_attribute attr; attribute_def def; pbs_attribute attrA; pbs_attribute attrB; memset(&attr,(unsigned)~0,sizeof(pbs_attribute)); memset(&def,0,sizeof(attribute_def)); memset(&attrA,0,sizeof(pbs_attribute)); memset(&attrB,0,sizeof(pbs_attribute)); def.at_type = ATR_TYPE_LIST; clear_attr(&attr,&def); fail_unless(attr.at_type == ATR_TYPE_LIST); attribute_def defa[3]; memset(defa,0,sizeof(defa)); defa[0].at_name = "Hello There."; defa[1].at_name = "Howdy Pard."; defa[2].at_name = "hello"; fail_unless(find_attr(defa,"HeLlo",3) == 2); fail_unless(find_attr(defa,"Hello there. ",3) == -1); attrA.at_val.at_long = 5; attrB.at_val.at_long = 6; fail_unless(attr_ifelse_long(&attrA,&attrB,3) == 3); attrB.at_flags = ATR_VFLAG_SET; fail_unless(attr_ifelse_long(&attrA,&attrB,3) == 6); attrA.at_flags = ATR_VFLAG_SET; fail_unless(attr_ifelse_long(&attrA,&attrB,3) == 5); free_null(&attrA); fail_unless(attrA.at_flags == 0); free_noop(&attrA); comp_null(&attrA,&attrB); }
static void tag_handle_link (int tagid, struct taginfo *tag, struct map_context *ctx) { int attrind; char *href = find_attr (tag, "href", &attrind); /* All <link href="..."> link references are external, except those known not to be, such as style sheet and shortcut icon: <link rel="stylesheet" href="..."> <link rel="shortcut icon" href="..."> */ if (href) { struct urlpos *up = append_url (href, ATTR_POS(tag,attrind,ctx), ATTR_SIZE(tag,attrind), ctx); if (up) { char *rel = find_attr (tag, "rel", NULL); if (rel) { if (0 == strcasecmp (rel, "stylesheet")) { up->link_inline_p = 1; up->link_expect_css = 1; } else if (0 == strcasecmp (rel, "shortcut icon")) { up->link_inline_p = 1; } else { /* The external ones usually point to HTML pages, such as <link rel="next" href="..."> except when the type attribute says otherwise: <link rel="alternate" type="application/rss+xml" href=".../?feed=rss2" /> */ char *type = find_attr (tag, "type", NULL); if (!type || strcasecmp (type, "text/html") == 0) up->link_expect_html = 1; } } } } }
status_t device_node::_RegisterDynamic(device_node* previous) { // If this is not a bus, we don't have to scan it if (find_attr(this, B_DEVICE_BUS, false, B_STRING_TYPE) == NULL) return B_OK; // If we're not being probed, we honour the B_FIND_CHILD_ON_DEMAND // requirements if (!IsProbed() && (fFlags & B_FIND_CHILD_ON_DEMAND) != 0 && !_AlwaysRegisterDynamic()) return B_OK; KPath path; if ((fFlags & B_FIND_MULTIPLE_CHILDREN) == 0) { // find the one driver driver_module_info* bestDriver = NULL; float bestSupport = 0.0; void* cookie = NULL; while (_GetNextDriverPath(cookie, path) == B_OK) { _FindBestDriver(path.Path(), bestDriver, bestSupport, previous); } if (bestDriver != NULL) { TRACE((" register best module \"%s\", support %f\n", bestDriver->info.name, bestSupport)); if (bestDriver->register_device(this) == B_OK) { // There can only be one node of this driver // (usually only one at all, but there might be a new driver // "waiting" for its turn) device_node* child = FindChild(bestDriver->info.name); if (child != NULL) { child->fSupportsParent = bestSupport; if (previous != NULL) { previous->fFlags |= NODE_FLAG_OBSOLETE_DRIVER; previous->Release(); child->fFlags |= NODE_FLAG_WAITING_FOR_DRIVER; } } // TODO: if this fails, we could try the second best driver, // and so on... } put_module(bestDriver->info.name); } } else { // register all drivers that match void* cookie = NULL; while (_GetNextDriverPath(cookie, path) == B_OK) { _RegisterPath(path.Path()); } } return B_OK; }
SaErrorT get_rpt_attr(Rpt_t *rpt, char *attr_name, union_type_t *val) { int i; if ((attr_name == (char *)NULL) || (val == (union_type_t *)NULL)) return(SA_ERR_HPI_INVALID_PARAMS); i = find_attr(&(rpt->Attrutes), attr_name); if (i < 0) return(SA_ERR_HPI_INVALID_PARAMS); *val = rpt->Attrutes.Attrs[i].value; return(SA_OK); }
int sched_recov_db(void) { pbs_db_conn_t *conn = (pbs_db_conn_t *) svr_db_conn; pbs_db_sched_info_t dbsched; pbs_db_attr_info_t attr_info; pbs_db_obj_info_t obj; int rc; int index; /* load server_qs */ strcpy(dbsched.sched_name, pbs_server_id); if (pbs_db_begin_trx(conn, 0, 0) !=0) goto db_err; obj.pbs_db_obj_type = PBS_DB_SCHED; obj.pbs_db_un.pbs_db_sched = &dbsched; /* read in job fixed sub-structure */ if ((rc = pbs_db_load_obj(conn, &obj)) == -1) /* error */ goto db_err; if (rc == 0) { db_to_svr_sched(&scheduler, &dbsched); attr_info.parent_id = pbs_server_id; attr_info.parent_obj_type = PARENT_TYPE_SCHED; /* svr attr */ /* read in server attributes */ if (recov_attr_db(conn, &scheduler, &attr_info, sched_attr_def, scheduler.sch_attr, (int)SCHED_ATR_LAST, 0) != 0) goto db_err; } if (pbs_db_end_trx(conn, PBS_DB_COMMIT) != 0) goto db_err; if (pbs_conf.pbs_use_tcp == 0) { /* check if throughput mode is visible in non-TPP mode, if so make it invisible */ index = find_attr(sched_attr_def, ATTR_throughput_mode, SCHED_ATR_LAST); scheduler.sch_attr[index].at_flags = 0; } return (0); db_err: log_err(-1, "sched_recov", "read of scheduler db failed"); (void) pbs_db_end_trx(conn, PBS_DB_ROLLBACK); return -1; }
static status_t get_attr_uint64(const device_node* node, const char* name, uint64* _value, bool recursive) { if (node == NULL || name == NULL || _value == NULL) return B_BAD_VALUE; device_attr_private* attr = find_attr(node, name, recursive, B_UINT64_TYPE); if (attr == NULL) return B_NAME_NOT_FOUND; *_value = attr->value.ui64; return B_OK; }
static status_t get_attr_string(const device_node* node, const char* name, const char** _value, bool recursive) { if (node == NULL || name == NULL || _value == NULL) return B_BAD_VALUE; device_attr_private* attr = find_attr(node, name, recursive, B_STRING_TYPE); if (attr == NULL) return B_NAME_NOT_FOUND; *_value = attr->value.string; return B_OK; }
SaErrorT get_rpt_attr_as_string(Rpt_t *rpt, char *attr_name, char *val, int len) { int i; SaErrorT ret; if ((attr_name == (char *)NULL) || (val == (char *)NULL) || (len == 0)) return(SA_ERR_HPI_INVALID_PARAMS); i = find_attr(&(rpt->Attrutes), attr_name); if (i < 0) return(SA_ERR_HPI_INVALID_PARAMS); ret = get_value_as_string(&(rpt->Attrutes), i, val, len); return(ret); }
static void tag_handle_form (int tagid, struct taginfo *tag, struct map_context *ctx) { int attrind; char *action = find_attr (tag, "action", &attrind); if (action) { struct urlpos *up = append_url (action, ATTR_POS(tag,attrind,ctx), ATTR_SIZE(tag,attrind), ctx); if (up) up->ignore_when_downloading = 1; } }
static status_t get_attr_raw(const device_node* node, const char* name, const void** _data, size_t* _length, bool recursive) { if (node == NULL || name == NULL || (_data == NULL && _length == NULL)) return B_BAD_VALUE; device_attr_private* attr = find_attr(node, name, recursive, B_RAW_TYPE); if (attr == NULL) return B_NAME_NOT_FOUND; if (_data != NULL) *_data = attr->value.raw.data; if (_length != NULL) *_length = attr->value.raw.length; return B_OK; }
static int read_entry_ref(xmlNode *entry_node, entry_ref_t **dst) { xmlAttr *a; const char *a_val; /* allocate memory and prepare empty node */ if (!dst) return -1; *dst = (entry_ref_t*)cds_malloc(sizeof(entry_ref_t)); if (!(*dst)) return -2; memset(*dst, 0, sizeof(entry_ref_t)); /* get attributes */ a = find_attr(entry_node->properties, "ref"); if (a) { a_val = get_attr_value(a); if (a_val) (*dst)->ref = zt_strdup(a_val); } return 0; }
void decode_attribute( svrattrl *pal, job **pjob, bool freeExisting) { int index; job *pj = *pjob; /* find the pbs_attribute definition based on the name */ index = find_attr(job_attr_def, pal->al_name, JOB_ATR_LAST); if (index < 0) index = JOB_ATR_UNKN; if (freeExisting) { job_attr_def[index].at_free(&pj->ji_wattr[index]); } if (index == JOB_ATR_hold) { // JOB_ATR_hold is written to file as a number so it won't decode correctly pj->ji_wattr[index].at_val.at_long = strtol(pal->al_value, NULL, 10); } else { job_attr_def[index].at_decode( &pj->ji_wattr[index], pal->al_name, pal->al_resc, pal->al_value, ATR_DFLAG_ACCESS); } if (job_attr_def[index].at_action != NULL) job_attr_def[index].at_action(&pj->ji_wattr[index], pj, ATR_ACTION_RECOV); pj->ji_wattr[index].at_flags = pal->al_flags & ~ATR_VFLAG_MODIFY; } // END decode_attribute()
static int read_name(xmlNode *name_node, display_name_t **dst) { xmlAttr *a; const char *a_val; /* allocate memory and prepare empty node */ if (!dst) return -1; *dst = (display_name_t*)cds_malloc(sizeof(display_name_t)); if (!(*dst)) return -2; memset(*dst, 0, sizeof(display_name_t)); /* get attributes */ a = find_attr(name_node->properties, "lang"); if (a) { a_val = get_attr_value(a); if (a_val) (*dst)->lang = zt_strdup(a_val); } a_val = get_node_value(name_node); if (a_val) (*dst)->name = zt_strdup(a_val); return 0; }
static void tag_handle_base (int tagid, struct taginfo *tag, struct map_context *ctx) { struct urlpos *base_urlpos; int attrind; char *newbase = find_attr (tag, "href", &attrind); if (!newbase) return; base_urlpos = append_url (newbase, ATTR_POS(tag,attrind,ctx), ATTR_SIZE(tag,attrind), ctx); if (!base_urlpos) return; base_urlpos->ignore_when_downloading = 1; base_urlpos->link_base_p = 1; if (ctx->base) xfree (ctx->base); if (ctx->parent_base) ctx->base = uri_merge (ctx->parent_base, newbase); else ctx->base = xstrdup (newbase); }
int attr_atomic_set( struct svrattrl *plist, pbs_attribute *old, pbs_attribute *new_attr, attribute_def *pdef, int limit, int unkn, int privil, int *badattr) { int acc; int index; int listidx; resource *prc; int rc; pbs_attribute temp; int resc_access_perm = privil; /* set privilege for decode_resc() */ for (index = 0;index < limit;index++) clear_attr(new_attr + index, pdef + index); listidx = 0; rc = PBSE_NONE; while (plist != NULL) { listidx++; if ((index = find_attr(pdef, plist->al_name, limit)) < 0) { if (unkn < 0) { /*unknown attr isn't allowed*/ rc = PBSE_NOATTR; break; } else { index = unkn; /* if unknown attr are allowed */ } } /* have we privilege to set the pbs_attribute ? */ acc = (pdef + index)->at_flags & ATR_DFLAG_ACCESS; if ((acc & privil & ATR_DFLAG_WRACC) == 0) { if (privil & ATR_DFLAG_SvWR) { /* from a daemon, just ignore this pbs_attribute */ plist = (svrattrl *)GET_NEXT(plist->al_link); continue; } /* from user, error if can't write pbs_attribute */ rc = PBSE_ATTRRO; break; } /* decode new_attr value */ clear_attr(&temp, pdef + index); /* * special gpu cases * 1) if only ncpus is specified, delete gpus resource if any * 2) if both ncpus and gpus specified, replace both */ if ((strcmp(plist->al_name,ATTR_l) == 0) && (strcmp(plist->al_resc,"ncpus") == 0)) { char *pc; if ((pc = strstr(plist->al_value,":gpus=")) != NULL) { /* save off gpu resource list then add new resource_list entry for it */ char *gpuval; gpuval = strdup(pc+6); (*pc) = '\0'; if (gpuval != NULL) { rc = (pdef + index)->at_decode(&temp, plist->al_name, (char *)"gpus", gpuval,ATR_DFLAG_ACCESS); free(gpuval); if (rc != 0) { if ((rc == PBSE_UNKRESC) && (unkn > 0)) rc = 0; /* ignore the "error" */ else break; } } } else { /* delete old resource_list.gpus value if any. * this can be done by setting it to zero */ rc = (pdef + index)->at_decode(&temp, plist->al_name, (char *)"gpus", 0,ATR_DFLAG_ACCESS); if (rc != 0) { if ((rc == PBSE_UNKRESC) && (unkn > 0)) rc = 0; /* ignore the "error" */ else break; } } } rc = (pdef + index)->at_decode(&temp, plist->al_name, plist->al_resc, plist->al_value,resc_access_perm); if (rc != 0) { if ((rc == PBSE_UNKRESC) && (unkn > 0)) rc = 0; /* ignore the "error" */ else break; } /* duplicate current value, if set AND not already dup-ed */ if (((old + index)->at_flags & ATR_VFLAG_SET) && !((new_attr + index)->at_flags & ATR_VFLAG_SET)) { if ((rc = (pdef + index)->at_set(new_attr + index, old + index, SET)) != 0) break; /* * we need to know if the value is changed during * the next step, so clear MODIFY here; including * within resources. */ (new_attr + index)->at_flags &= ~ATR_VFLAG_MODIFY; if ((new_attr + index)->at_type == ATR_TYPE_RESC) { prc = (resource *)GET_NEXT((new_attr + index)->at_val.at_list); while (prc) { prc->rs_value.at_flags &= ~ATR_VFLAG_MODIFY; prc = (resource *)GET_NEXT(prc->rs_link); } } } /* update new copy with temp, MODIFY is set on ones changed */ if ((plist->al_op != INCR) && (plist->al_op != DECR) && (plist->al_op != SET) && (plist->al_op != INCR_OLD)) { plist->al_op = SET; } if (temp.at_flags & ATR_VFLAG_SET) { if ((rc = (pdef + index)->at_set(new_attr + index, &temp, plist->al_op)) != 0) { (pdef + index)->at_free(&temp); break; } } else if (temp.at_flags & ATR_VFLAG_MODIFY) { (pdef + index)->at_free(new_attr + index); (new_attr + index)->at_flags |= ATR_VFLAG_MODIFY; } (pdef + index)->at_free(&temp); if (plist->al_link.ll_next == NULL) break; plist = (struct svrattrl *)GET_NEXT(plist->al_link); } /* END while (plist != NULL) */ if (rc != 0) { *badattr = listidx; for (index = 0; index < limit; index++) (pdef + index)->at_free(new_attr + index); return(rc); } return(0); } /* END attr_atomic_set() */
int str_to_attr( const char *name, /* I */ char *val, /* I */ pbs_attribute *attr, /* O */ struct attribute_def *padef, /* I */ int limit) /* I */ { int index; char buf[MAXLINE<<5]; char log_buf[LOCAL_LOG_BUF_SIZE]; if ((name == NULL) || (val == NULL) || (attr == NULL)) { return(-10); } index = find_attr(padef,name,limit); if (index < 0) return(ATTR_NOT_FOUND); switch (padef[index].at_type) { case ATR_TYPE_LONG: attr[index].at_val.at_long = strtol(val, NULL, 10); break; case ATR_TYPE_CHAR: attr[index].at_val.at_char = *val; break; case ATR_TYPE_STR: unescape_xml(val,buf,sizeof(buf)); attr[index].at_val.at_str = strdup(buf); if (attr[index].at_val.at_str == NULL) { log_err(PBSE_SYSTEM, __func__, "Cannot allocate memory\n"); return(PBSE_SYSTEM); } break; case ATR_TYPE_ARST: case ATR_TYPE_ACL: { int rc; unescape_xml(val,buf,sizeof(buf)); if ((rc = decode_arst(attr + index,name,NULL,buf,0))) return(rc); } break; case ATR_TYPE_SIZE: { unsigned long number; char *unit; number = strtol(val, NULL, 10); attr[index].at_val.at_size.atsv_units = ATR_SV_BYTESZ; attr[index].at_val.at_size.atsv_num = number; attr[index].at_val.at_size.atsv_shift = 0; /* the string always ends with kb,mb if it has units */ unit = val + strlen(val) - 2; if (unit < val) break; else if (isdigit(*val)) break; switch (*unit) { case 'k': attr[index].at_val.at_size.atsv_shift = 10; break; case 'm': attr[index].at_val.at_size.atsv_shift = 20; break; case 'g': attr[index].at_val.at_size.atsv_shift = 30; break; case 't': attr[index].at_val.at_size.atsv_shift = 40; break; case 'p': attr[index].at_val.at_size.atsv_shift = 50; break; } } break; case ATR_TYPE_RESC: { char *resc_parent; char *resc_child; char *resc_ptr = val; int len = strlen(resc_ptr); int rc; int errFlg = 0; while (resc_ptr - val < len) { if (get_parent_and_child(resc_ptr,&resc_parent,&resc_child, &resc_ptr)) { errFlg = TRUE; break; } if ((rc = decode_resc(&(attr[index]),name,resc_parent,resc_child,ATR_DFLAG_ACCESS))) { snprintf(log_buf,sizeof(log_buf), "Error decoding resource %s, %s = %s\n", name, resc_parent, resc_child); errFlg = TRUE; log_err(rc, __func__, log_buf); } } if (errFlg == TRUE) return(-1); } break; /* NYI */ case ATR_TYPE_LIST: case ATR_TYPE_LL: case ATR_TYPE_SHORT: case ATR_TYPE_JINFOP: break; } /* END switch (pbs_attribute type) */ attr[index].at_flags |= ATR_VFLAG_SET; return(PBSE_NONE); } /* END str_to_attr */
int area_area(struct Map_info *In, int *field, struct Map_info *Tmp, struct Map_info *Out, struct field_info *Fi, dbDriver * driver, int operator, int *ofield, ATTRIBUTES * attr, struct ilist *BList, double snap) { int ret, input, line, nlines, area, nareas; int in_area, in_centr, out_cat; struct line_pnts *Points; struct line_cats *Cats; CENTR *Centr; char buf[1000]; dbString stmt; int nmodif; int verbose; verbose = G_verbose(); Points = Vect_new_line_struct(); Cats = Vect_new_cats_struct(); /* optional snap */ if (snap > 0) { int i, j, snapped_lines = 0; struct bound_box box; struct boxlist *boxlist = Vect_new_boxlist(0); struct ilist *reflist = Vect_new_list(); G_message(_("Snapping boundaries with %g ..."), snap); /* snap boundaries in B to boundaries in A, * not modifying boundaries in A */ if (BList->n_values > 1) qsort(BList->value, BList->n_values, sizeof(int), cmp_int); snapped_lines = 0; nlines = BList->n_values; for (i = 0; i < nlines; i++) { line = BList->value[i]; Vect_read_line(Tmp, Points, Cats, line); /* select lines by box */ Vect_get_line_box(Tmp, line, &box); box.E += snap; box.W -= snap; box.N += snap; box.S -= snap; box.T = 0.0; box.B = 0.0; Vect_select_lines_by_box(Tmp, &box, GV_BOUNDARY, boxlist); if (boxlist->n_values > 0) { Vect_reset_list(reflist); for (j = 0; j < boxlist->n_values; j++) { int aline = boxlist->id[j]; if (!bsearch(&aline, BList->value, BList->n_values, sizeof(int), cmp_int)) { G_ilist_add(reflist, aline); } } /* snap bline to alines */ if (Vect_snap_line(Tmp, reflist, Points, snap, 0, NULL, NULL)) { /* rewrite bline*/ Vect_delete_line(Tmp, line); ret = Vect_write_line(Tmp, GV_BOUNDARY, Points, Cats); G_ilist_add(BList, ret); snapped_lines++; G_debug(3, "line %d snapped", line); } } } Vect_destroy_boxlist(boxlist); Vect_destroy_list(reflist); G_verbose_message(n_("%d boundary snapped", "%d boundaries snapped", snapped_lines), snapped_lines); } /* same procedure like for v.in.ogr: * Vect_clean_small_angles_at_nodes() can change the geometry so that new intersections * are created. We must call Vect_break_lines(), Vect_remove_duplicates() * and Vect_clean_small_angles_at_nodes() until no more small dangles are found */ do { G_message(_("Breaking lines...")); Vect_break_lines_list(Tmp, NULL, BList, GV_BOUNDARY, NULL); /* Probably not necessary for LINE x AREA */ G_message(_("Removing duplicates...")); Vect_remove_duplicates(Tmp, GV_BOUNDARY, NULL); G_message(_("Cleaning boundaries at nodes...")); nmodif = Vect_clean_small_angles_at_nodes(Tmp, GV_BOUNDARY, NULL); } while (nmodif > 0); /* ?: May be result of Vect_break_lines() + Vect_remove_duplicates() any dangle or bridge? * In that case, calls to Vect_remove_dangles() and Vect_remove_bridges() would be also necessary */ G_set_verbose(0); /* should be fast, be silent */ Vect_build_partial(Tmp, GV_BUILD_AREAS); G_set_verbose(verbose); nlines = Vect_get_num_lines(Tmp); ret = 0; for (line = 1; line <= nlines; line++) { if (!Vect_line_alive(Tmp, line)) continue; if (Vect_get_line_type(Tmp, line) == GV_BOUNDARY) { int left, rite; Vect_get_line_areas(Tmp, line, &left, &rite); if (left == 0 || rite == 0) { /* invalid boundary */ ret = 1; break; } } } if (ret) { Vect_remove_dangles(Tmp, GV_BOUNDARY, -1, NULL); Vect_remove_bridges(Tmp, NULL, NULL, NULL); } G_set_verbose(0); Vect_build_partial(Tmp, GV_BUILD_NONE); Vect_build_partial(Tmp, GV_BUILD_BASE); G_set_verbose(verbose); G_message(_("Merging lines...")); Vect_merge_lines(Tmp, GV_BOUNDARY, NULL, NULL); /* Attach islands */ G_message(_("Attaching islands...")); /* can take some time, show messages */ Vect_build_partial(Tmp, GV_BUILD_ATTACH_ISLES); /* Calculate new centroids for all areas */ nareas = Vect_get_num_areas(Tmp); Centr = (CENTR *) G_malloc((nareas + 1) * sizeof(CENTR)); /* index from 1 ! */ for (area = 1; area <= nareas; area++) { ret = Vect_get_point_in_area(Tmp, area, &(Centr[area].x), &(Centr[area].y)); if (ret < 0) { G_warning(_("Cannot calculate area centroid")); Centr[area].valid = 0; } else { Centr[area].valid = 1; } } /* Query input maps */ for (input = 0; input < 2; input++) { G_message(_("Querying vector map <%s>..."), Vect_get_full_name(&(In[input]))); for (area = 1; area <= nareas; area++) { Centr[area].cat[input] = Vect_new_cats_struct(); G_percent(area, nareas, 1); in_area = Vect_find_area(&(In[input]), Centr[area].x, Centr[area].y); if (in_area > 0) { in_centr = Vect_get_area_centroid(&(In[input]), in_area); if (in_centr > 0) { int i; Vect_read_line(&(In[input]), NULL, Cats, in_centr); /* Add all cats with original field number */ for (i = 0; i < Cats->n_cats; i++) { if (Cats->field[i] == field[input]) { ATTR *at; Vect_cat_set(Centr[area].cat[input], ofield[input + 1], Cats->cat[i]); /* Mark as used */ at = find_attr(&(attr[input]), Cats->cat[i]); if (!at) G_fatal_error(_("Attribute not found")); at->used = 1; } } } } } } G_message(_("Writing centroids...")); db_init_string(&stmt); out_cat = 1; for (area = 1; area <= nareas; area++) { int i; G_percent(area, nareas, 1); /* check the condition */ switch (operator) { case OP_AND: if (! (Centr[area].cat[0]->n_cats > 0 && Centr[area].cat[1]->n_cats > 0)) continue; break; case OP_OR: if (! (Centr[area].cat[0]->n_cats > 0 || Centr[area].cat[1]->n_cats > 0)) continue; break; case OP_NOT: if (! (Centr[area].cat[0]->n_cats > 0 && !(Centr[area].cat[1]->n_cats > 0))) continue; break; case OP_XOR: if ((Centr[area].cat[0]->n_cats > 0 && Centr[area].cat[1]->n_cats > 0) || (!(Centr[area].cat[0]->n_cats > 0) && !(Centr[area].cat[1]->n_cats > 0))) continue; break; } Vect_reset_line(Points); Vect_reset_cats(Cats); Vect_append_point(Points, Centr[area].x, Centr[area].y, 0.0); if (ofield[0] > 0) { /* Add new cats for all combinations of input cats (-1 in cycle for null) */ for (i = -1; i < Centr[area].cat[0]->n_cats; i++) { int j; if (i == -1 && Centr[area].cat[0]->n_cats > 0) continue; /* no need to make null */ for (j = -1; j < Centr[area].cat[1]->n_cats; j++) { if (j == -1 && Centr[area].cat[1]->n_cats > 0) continue; /* no need to make null */ if (ofield[0] > 0) Vect_cat_set(Cats, ofield[0], out_cat); /* attributes */ if (driver) { ATTR *at; sprintf(buf, "insert into %s values ( %d", Fi->table, out_cat); db_set_string(&stmt, buf); /* cata */ if (i >= 0) { if (attr[0].columns) { at = find_attr(&(attr[0]), Centr[area].cat[0]->cat[i]); if (!at) G_fatal_error(_("Attribute not found")); if (at->values) db_append_string(&stmt, at->values); else db_append_string(&stmt, attr[0].null_values); } else { sprintf(buf, ", %d", Centr[area].cat[0]->cat[i]); db_append_string(&stmt, buf); } } else { if (attr[0].columns) { db_append_string(&stmt, attr[0].null_values); } else { sprintf(buf, ", null"); db_append_string(&stmt, buf); } } /* catb */ if (j >= 0) { if (attr[1].columns) { at = find_attr(&(attr[1]), Centr[area].cat[1]->cat[j]); if (!at) G_fatal_error(_("Attribute not found")); if (at->values) db_append_string(&stmt, at->values); else db_append_string(&stmt, attr[1].null_values); } else { sprintf(buf, ", %d", Centr[area].cat[1]->cat[j]); db_append_string(&stmt, buf); } } else { if (attr[1].columns) { db_append_string(&stmt, attr[1].null_values); } else { sprintf(buf, ", null"); db_append_string(&stmt, buf); } } db_append_string(&stmt, " )"); G_debug(3, "%s", db_get_string(&stmt)); if (db_execute_immediate(driver, &stmt) != DB_OK) G_warning(_("Unable to insert new record: '%s'"), db_get_string(&stmt)); } out_cat++; } } } /* Add all cats from input vectors */ if (ofield[1] > 0 && field[0] > 0) { for (i = 0; i < Centr[area].cat[0]->n_cats; i++) { if (Centr[area].cat[0]->field[i] == field[0]) Vect_cat_set(Cats, ofield[1], Centr[area].cat[0]->cat[i]); } } if (ofield[2] > 0 && field[1] > 0 && ofield[1] != ofield[2]) { for (i = 0; i < Centr[area].cat[1]->n_cats; i++) { if (Centr[area].cat[1]->field[i] == field[1]) Vect_cat_set(Cats, ofield[2], Centr[area].cat[1]->cat[i]); } } Vect_write_line(Tmp, GV_CENTROID, Points, Cats); Vect_write_line(Out, GV_CENTROID, Points, Cats); } G_set_verbose(0); /* should be fast, be silent */ Vect_build_partial(Tmp, GV_BUILD_CENTROIDS); G_set_verbose(verbose); /* Copy valid boundaries to final output */ nlines = Vect_get_num_lines(Tmp); for (line = 1; line <= nlines; line++) { int i, ltype, side[2], centr[2]; G_percent(line, nlines, 1); /* must be before any continue */ if (!Vect_line_alive(Tmp, line)) continue; ltype = Vect_read_line(Tmp, Points, Cats, line); if (!(ltype & GV_BOUNDARY)) continue; Vect_get_line_areas(Tmp, line, &side[0], &side[1]); for (i = 0; i < 2; i++) { if (side[i] == 0) { /* This should not happen ! */ centr[i] = 0; continue; } if (side[i] > 0) { area = side[i]; } else { /* island */ area = Vect_get_isle_area(Tmp, abs(side[i])); } if (area > 0) centr[i] = Vect_get_area_centroid(Tmp, area); else centr[i] = 0; } if (centr[0] || centr[1]) Vect_write_line(Out, GV_BOUNDARY, Points, Cats); } return 0; }
/* * get_specific_attributes_status() * * Returns the specific attributes specified in pal instead of looping over * all attributes. * * @param pal - the list of attributes to enode * @param padef - the attribute definition to work from * @param pattr - the attribute list we are encoding from * @param phead - the list we're encoding onto * @param priv - the privileges of the encoder * @param limit - the number of attributes in padef * @param bad - the attribute index that is bad. Output * @param IsOwner - TRUE if the encoder is an owner of this object, FALSE otherwise * @return - PBSE_NONE if successful, otherwise the appropriate pbs error code */ int get_specific_attributes_status( svrattrl *pal, /* I */ attribute_def *padef, pbs_attribute *pattr, tlist_head *phead, int priv, int limit, int *bad, int IsOwner) { int nth = 0; char log_buf[LOCAL_LOG_BUF_SIZE + 1]; int resc_access_perm; priv &= ATR_DFLAG_RDACC; /* user-client privilege */ resc_access_perm = priv; while (pal != NULL) { ++nth; int index = find_attr(padef, pal->al_name, limit); if (index < 0) { *bad = nth; snprintf(log_buf, LOCAL_LOG_BUF_SIZE, "Attribute %s not found. nth = %d", pal->al_name, nth); LOG_EVENT(PBSEVENT_JOB, PBS_EVENTCLASS_QUEUE, __func__, log_buf); /* FAILURE */ return(PBSE_NOATTR); } if ((padef + index)->at_flags & priv) { if (!(((padef + index)->at_flags & ATR_DFLAG_PRIVR) && (IsOwner == 0))) { (padef + index)->at_encode( pattr + index, phead, (padef + index)->at_name, NULL, ATR_ENCODE_CLIENT, resc_access_perm); } } pal = (svrattrl *)GET_NEXT(pal->al_link); } if (padef == job_attr_def) { /* We want to return walltime remaining for all running jobs */ if ((pattr + JOB_ATR_start_time)->at_flags & ATR_VFLAG_SET) add_walltime_remaining(JOB_ATR_start_time, pattr, phead); } /* SUCCESS */ return(PBSE_NONE); } // END get_specific_attributes_values()
int modify_job( void **j, /* O */ svrattrl *plist, /* I */ struct batch_request *preq, /* I */ int checkpoint_req, /* I */ int flag) /* I */ { int bad = 0; int i; int newstate; int newsubstate; resource_def *prsd; int rc; int sendmom = 0; int copy_checkpoint_files = FALSE; char log_buf[LOCAL_LOG_BUF_SIZE]; struct batch_request *dup_req = NULL; job *pjob = (job *)*j; if (pjob == NULL) { sprintf(log_buf, "job structure is NULL"); log_err(PBSE_IVALREQ, __func__, log_buf); return(PBSE_IVALREQ); } /* cannot be in exiting or transit, exiting has already been checked */ if (pjob->ji_qs.ji_state == JOB_STATE_TRANSIT) { /* FAILURE */ snprintf(log_buf,sizeof(log_buf), "Cannot modify job '%s' in transit\n", pjob->ji_qs.ji_jobid); log_err(PBSE_BADSTATE, __func__, log_buf); return(PBSE_BADSTATE); } if (((checkpoint_req == CHK_HOLD) || (checkpoint_req == CHK_CONT)) && (pjob->ji_qs.ji_substate == JOB_SUBSTATE_RUNNING)) { /* May need to request copy of the checkpoint file from mom */ copy_checkpoint_files = TRUE; if (checkpoint_req == CHK_HOLD) { sprintf(log_buf,"setting jobsubstate for %s to RERUN\n", pjob->ji_qs.ji_jobid); pjob->ji_qs.ji_substate = JOB_SUBSTATE_RERUN; job_save(pjob, SAVEJOB_QUICK, 0); log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, pjob->ji_qs.ji_jobid, log_buf); /* remove checkpoint restart file if there is one */ if (pjob->ji_wattr[JOB_ATR_restart_name].at_flags & ATR_VFLAG_SET) { cleanup_restart_file(pjob); } } } /* if job is running, special checks must be made */ /* NOTE: must determine if job exists down at MOM - this will occur if job is running, job is held, or job was held and just barely released (ie qhold/qrls) */ /* COMMENTED OUT BY JOSH B IN 2.3 DUE TO MAJOR PROBLEMS w/ CUSTOMERS * --FIX and uncomment once we know what is really going on. * * We now know that ji_destin gets set on a qmove and that the mom does not * have the job at that point. * if ((pjob->ji_qs.ji_state == JOB_STATE_RUNNING) || ((pjob->ji_qs.ji_state == JOB_STATE_HELD) && (pjob->ji_qs.ji_destin[0] != '\0')) || ((pjob->ji_qs.ji_state == JOB_STATE_QUEUED) && (pjob->ji_qs.ji_destin[0] != '\0'))) */ if (pjob->ji_qs.ji_state == JOB_STATE_RUNNING) { while (plist != NULL) { /* is the pbs_attribute modifiable in RUN state ? */ i = find_attr(job_attr_def, plist->al_name, JOB_ATR_LAST); if ((i < 0) || ((job_attr_def[i].at_flags & ATR_DFLAG_ALTRUN) == 0)) { /* FAILURE */ snprintf(log_buf,sizeof(log_buf), "Cannot modify attribute '%s' while running\n", plist->al_name); log_err(PBSE_MODATRRUN, __func__, log_buf); return PBSE_MODATRRUN; } /* NOTE: only explicitly specified job attributes are routed down to MOM */ if (i == JOB_ATR_resource) { /* is the specified resource modifiable while */ /* the job is running */ prsd = find_resc_def(svr_resc_def, plist->al_resc, svr_resc_size); if (prsd == NULL) { /* FAILURE */ snprintf(log_buf,sizeof(log_buf), "Unknown attribute '%s'\n", plist->al_name); log_err(PBSE_UNKRESC, __func__, log_buf); return(PBSE_UNKRESC); } if ((prsd->rs_flags & ATR_DFLAG_ALTRUN) == 0) { /* FAILURE */ snprintf(log_buf,sizeof(log_buf), "Cannot modify attribute '%s' while running\n", plist->al_name); log_err(PBSE_MODATRRUN, __func__, log_buf); return(PBSE_MODATRRUN); } sendmom = 1; } /* else if ((i == JOB_ATR_checkpoint_name) || (i == JOB_ATR_variables)) { sendmom = 1; } */ plist = (svrattrl *)GET_NEXT(plist->al_link); } } /* END if (pjob->ji_qs.ji_state == JOB_STATE_RUNNING) */ /* modify the job's attributes */ bad = 0; plist = (svrattrl *)GET_NEXT(preq->rq_ind.rq_modify.rq_attr); rc = modify_job_attr(pjob, plist, preq->rq_perm, &bad); if (rc) { /* FAILURE */ snprintf(log_buf,sizeof(log_buf), "Cannot set attributes for job '%s'\n", pjob->ji_qs.ji_jobid); log_err(rc, __func__, log_buf); if (rc == PBSE_JOBNOTFOUND) *j = NULL; return(rc); } /* Reset any defaults resource limit which might have been unset */ set_resc_deflt(pjob, NULL, FALSE); /* if job is not running, may need to change its state */ if (pjob->ji_qs.ji_state != JOB_STATE_RUNNING) { svr_evaljobstate(pjob, &newstate, &newsubstate, 0); svr_setjobstate(pjob, newstate, newsubstate, FALSE); } else { job_save(pjob, SAVEJOB_FULL, 0); } sprintf(log_buf, msg_manager, msg_jobmod, preq->rq_user, preq->rq_host); log_event(PBSEVENT_JOB,PBS_EVENTCLASS_JOB,pjob->ji_qs.ji_jobid,log_buf); /* if a resource limit changed for a running job, send to MOM */ if (sendmom) { /* if the NO_MOM_RELAY flag is set the calling function will call relay_to_mom so we do not need to do it here */ if (flag != NO_MOM_RELAY) { /* The last number is unused unless this is an array */ if ((rc = copy_batchrequest(&dup_req, preq, 0, -1)) != 0) { } /* The dup_req is freed in relay_to_mom (failure) * or in issue_Drequest (success) */ else if ((rc = relay_to_mom(&pjob, dup_req, post_modify_req))) { if (pjob != NULL) { snprintf(log_buf,sizeof(log_buf), "Unable to relay information to mom for job '%s'\n", pjob->ji_qs.ji_jobid); log_err(rc, __func__, log_buf); } return(rc); /* unable to get to MOM */ } } return(PBSE_RELAYED_TO_MOM); } if (copy_checkpoint_files) { struct batch_request *momreq = 0; momreq = cpy_checkpoint(momreq, pjob, JOB_ATR_checkpoint_name, CKPT_DIR_OUT); if (momreq != NULL) { /* have files to copy */ momreq->rq_extra = strdup(pjob->ji_qs.ji_jobid); /* The momreq is freed in relay_to_mom (failure) * or in issue_Drequest (success) */ if (checkpoint_req == CHK_HOLD) { rc = relay_to_mom(&pjob, momreq, chkpt_xfr_hold); } else { rc = relay_to_mom(&pjob, momreq, chkpt_xfr_done); } if (rc != 0) { if (pjob != NULL) { snprintf(log_buf,sizeof(log_buf), "Unable to relay information to mom for job '%s'\n", pjob->ji_qs.ji_jobid); log_err(rc, __func__, log_buf); } return(PBSE_NONE); /* come back when mom replies */ } } else { log_err(-1, __func__, "Failed to get batch request"); } } return(PBSE_NONE); } /* END modify_job() */
/** * @brief Service the Modify Reservation Request from client such as pbs_ralter. * * This request atomically modifies one or more of a reservation's attributes. * An error is returned to the client if the user does not have permission * to perform the modification, the attribute is read-only, the reservation is * running and the attribute is only modifiable when the reservation is not * running or is empty. * * @param[in] preq - pointer to batch request from client */ void req_modifyReservation(struct batch_request *preq) { char *rid = NULL; svrattrl *psatl = NULL; attribute_def *pdef = NULL; int rc = 0; int bad = 0; char buf[PBS_MAXUSER + PBS_MAXHOSTNAME + 32] = {0}; int sock; int resc_access_perm_save = 0; int send_to_scheduler = 0; int log_len = 0; char *fmt = "%a %b %d %H:%M:%S %Y"; int is_standing = 0; int next_occr_start = 0; extern char *msg_stdg_resv_occr_conflict; resc_resv *presv; if (preq == NULL) return; sock = preq->rq_conn; presv = chk_rescResv_request(preq->rq_ind.rq_modify.rq_objname, preq); /* Note: on failure, chk_rescResv_request invokes req_reject * appropriate reply is sent and batch_request is freed. */ if (presv == NULL) return; rid = preq->rq_ind.rq_modify.rq_objname; if ((presv = find_resv(rid)) == NULL) { /* Not on "all_resvs" list try "new_resvs" list */ presv = (resc_resv *)GET_NEXT(svr_newresvs); while (presv) { if (!strcmp(presv->ri_qs.ri_resvID, rid)) break; presv = (resc_resv *)GET_NEXT(presv->ri_allresvs); } } if (presv == NULL) { req_reject(PBSE_UNKRESVID, 0, preq); return; } is_standing = presv->ri_wattr[RESV_ATR_resv_standing].at_val.at_long; if (is_standing) next_occr_start = get_occurrence(presv->ri_wattr[RESV_ATR_resv_rrule].at_val.at_str, presv->ri_wattr[RESV_ATR_start].at_val.at_long, presv->ri_wattr[RESV_ATR_resv_timezone].at_val.at_str, 2); resc_access_perm_save = resc_access_perm; psatl = (svrattrl *)GET_NEXT(preq->rq_ind.rq_modify.rq_attr); presv->ri_alter_flags = 0; while (psatl) { long temp = 0; char *end = NULL; int index; /* identify the attribute by name */ index = find_attr(resv_attr_def, psatl->al_name, RESV_ATR_LAST); if (index < 0) { /* didn`t recognize the name */ reply_badattr(PBSE_NOATTR, 1, psatl, preq); return; } pdef = &resv_attr_def[index]; /* Does attribute's definition flags indicate that * we have sufficient permission to write the attribute? */ resc_access_perm = resc_access_perm_save; /* reset */ if (psatl->al_flags & ATR_VFLAG_HOOK) { resc_access_perm = ATR_DFLAG_USWR | \ ATR_DFLAG_OPWR | \ ATR_DFLAG_MGWR | \ ATR_DFLAG_SvWR | \ ATR_DFLAG_Creat; } if ((pdef->at_flags & resc_access_perm) == 0) { reply_badattr(PBSE_ATTRRO, 1, psatl, preq); return; } switch (index) { case RESV_ATR_start: if ((presv->ri_wattr[RESV_ATR_state].at_val.at_long != RESV_RUNNING) || !(presv->ri_qp->qu_numjobs)) { temp = strtol(psatl->al_value, &end, 10); if ((temp > time(NULL)) && (temp != presv->ri_wattr[RESV_ATR_start].at_val.at_long)) { if (!is_standing || (temp < next_occr_start)) { send_to_scheduler = RESV_START_TIME_MODIFIED; presv->ri_alter_stime = presv->ri_wattr[RESV_ATR_start].at_val.at_long; presv->ri_alter_flags |= RESV_START_TIME_MODIFIED; } else { snprintf(log_buffer, sizeof(log_buffer), "%s", msg_stdg_resv_occr_conflict); log_event(PBSEVENT_RESV, PBS_EVENTCLASS_RESV, LOG_INFO, preq->rq_ind.rq_modify.rq_objname, log_buffer); req_reject(PBSE_STDG_RESV_OCCR_CONFLICT, 0, preq); return; } } else { req_reject(PBSE_BADTSPEC, 0, preq); return; } } else { if (presv->ri_qp->qu_numjobs) req_reject(PBSE_RESV_NOT_EMPTY, 0, preq); else req_reject(PBSE_BADTSPEC, 0, preq); return; } break; case RESV_ATR_end: temp = strtol(psatl->al_value, &end, 10); if (temp == presv->ri_wattr[RESV_ATR_end].at_val.at_long) { req_reject(PBSE_BADTSPEC, 0, preq); return; } if (!is_standing || temp < next_occr_start) { send_to_scheduler = RESV_END_TIME_MODIFIED; presv->ri_alter_etime = presv->ri_wattr[RESV_ATR_end].at_val.at_long; presv->ri_alter_flags |= RESV_END_TIME_MODIFIED; } else { snprintf(log_buffer, sizeof(log_buffer), "%s", msg_stdg_resv_occr_conflict); log_event(PBSEVENT_RESV, PBS_EVENTCLASS_RESV, LOG_INFO, preq->rq_ind.rq_modify.rq_objname, log_buffer); req_reject(PBSE_STDG_RESV_OCCR_CONFLICT, 0, preq); return; } break; default: break; } /* decode attribute */ rc = pdef->at_decode(&presv->ri_wattr[index], psatl->al_name, psatl->al_resc, psatl->al_value); if (rc != 0) { reply_badattr(rc, 1, psatl, preq); return; } psatl = (svrattrl *)GET_NEXT(psatl->al_link); } resc_access_perm = resc_access_perm_save; /* restore perm */ if (send_to_scheduler) { presv->ri_alter_state = presv->ri_wattr[RESV_ATR_state].at_val.at_long; resv_setResvState(presv, RESV_BEING_ALTERED, presv->ri_qs.ri_substate); /*"start", "end","duration", and "wall"; derive and check */ if (start_end_dur_wall(presv, RESC_RESV_OBJECT)) { req_reject(PBSE_BADTSPEC, 0, preq); resv_revert_alter_times(presv); return; } presv->ri_wattr[RESV_ATR_resource].at_flags |= ATR_VFLAG_SET | ATR_VFLAG_MODIFY | ATR_VFLAG_MODCACHE; } bad = 0; psatl = (svrattrl *)GET_NEXT(preq->rq_ind.rq_modify.rq_attr); if (psatl) rc = modify_resv_attr(presv, psatl, preq->rq_perm, &bad); if (send_to_scheduler) set_scheduler_flag(SCH_SCHEDULE_RESV_RECONFIRM, dflt_scheduler); (void)sprintf(log_buffer, "Attempting to modify reservation"); if (presv->ri_alter_flags & RESV_START_TIME_MODIFIED) { strftime(buf, sizeof(buf), fmt, localtime((time_t *) &presv->ri_wattr[RESV_ATR_start].at_val.at_long)); log_len = strlen(log_buffer); snprintf(log_buffer + log_len, sizeof(log_buffer) - log_len," start=%s", buf); } if (presv->ri_alter_flags & RESV_END_TIME_MODIFIED) { strftime(buf, sizeof(buf), fmt, localtime((time_t *) &presv->ri_wattr[RESV_ATR_end].at_val.at_long)); log_len = strlen(log_buffer); snprintf(log_buffer + log_len, sizeof(log_buffer) - log_len," end=%s", buf); } log_event(PBSEVENT_RESV, PBS_EVENTCLASS_RESV, LOG_INFO, preq->rq_ind.rq_modify.rq_objname, log_buffer); if ((presv->ri_wattr[RESV_ATR_interactive].at_flags & ATR_VFLAG_SET) == 0) { char buf1[PBS_MAXUSER + PBS_MAXHOSTNAME + 32] = {0}; /*Not "interactive" so don't wait on scheduler, reply now*/ sprintf(buf, "%s ALTER REQUESTED", presv->ri_qs.ri_resvID); sprintf(buf1, "requestor=%s@%s", preq->rq_user, preq->rq_host); if ((rc = reply_text(preq, PBSE_NONE, buf))) { /* reply failed, close connection; DON'T purge resv */ close_client(sock); return; } } else { /*Don't reply back until scheduler decides*/ long dt; presv->ri_brp = preq; dt = presv->ri_wattr[RESV_ATR_interactive].at_val.at_long; /*reply with id and state no decision in +dt secs*/ (void)gen_future_reply(presv, dt); (void)snprintf(buf, sizeof(buf), "requestor=%s@%s Interactive=%ld", preq->rq_user, preq->rq_host, dt); } }
void req_modifyjob(struct batch_request *preq) { int add_to_am_list = 0; /* if altered during sched cycle */ int bad = 0; int jt; /* job type */ int newstate; int newsubstate; resource_def *outsideselect = NULL; job *pjob; svrattrl *plist; resource *presc; resource_def *prsd; int rc; int running = 0; int sendmom = 0; char hook_msg[HOOK_MSG_SIZE]; int mod_project = 0; pbs_sched *psched; switch (process_hooks(preq, hook_msg, sizeof(hook_msg), pbs_python_set_interrupt)) { case 0: /* explicit reject */ reply_text(preq, PBSE_HOOKERROR, hook_msg); return; case 1: /* explicit accept */ if (recreate_request(preq) == -1) { /* error */ /* we have to reject the request, as 'preq' */ /* may have been partly modified */ strcpy(hook_msg, "modifyjob event: rejected request"); log_event(PBSEVENT_ERROR, PBS_EVENTCLASS_HOOK, LOG_ERR, "", hook_msg); reply_text(preq, PBSE_HOOKERROR, hook_msg); return; } break; case 2: /* no hook script executed - go ahead and accept event*/ break; default: log_event(PBSEVENT_DEBUG2, PBS_EVENTCLASS_HOOK, LOG_INFO, "", "modifyjob event: accept req by default"); } if (pseldef == NULL) /* do one time to keep handy */ pseldef = find_resc_def(svr_resc_def, "select", svr_resc_size); pjob = chk_job_request(preq->rq_ind.rq_modify.rq_objname, preq, &jt); if (pjob == NULL) return; if ((jt == IS_ARRAY_Single) || (jt == IS_ARRAY_Range)) { req_reject(PBSE_IVALREQ, 0, preq); return; } psched = find_sched_from_sock(preq->rq_conn); /* allow scheduler to modify job */ if (psched == NULL) { /* provisioning job is not allowed to be modified */ if ((pjob->ji_qs.ji_state == JOB_STATE_RUNNING) && (pjob->ji_qs.ji_substate == JOB_SUBSTATE_PROVISION)) { req_reject(PBSE_BADSTATE, 0, preq); return; } } /* cannot be in exiting or transit, exiting has already be checked */ if (pjob->ji_qs.ji_state == JOB_STATE_TRANSIT) { req_reject(PBSE_BADSTATE, 0, preq); return; } plist = (svrattrl *)GET_NEXT(preq->rq_ind.rq_modify.rq_attr); if (plist == NULL) { /* nothing to do */ reply_ack(preq); return; } /* * Special checks must be made: * if during a scheduling cycle and certain attributes are altered, * make a note of the job to prevent it from being run now; * if job is running, only certain attributes/resources can be * altered. */ if (pjob->ji_qs.ji_state == JOB_STATE_RUNNING) { running = 1; } while (plist) { int i; i = find_attr(job_attr_def, plist->al_name, JOB_ATR_LAST); /* * Is the attribute being altered one which could change * scheduling (ATR_DFLAG_SCGALT set) and if a scheduling * cycle is in progress, then set flag to add the job to list * of jobs which cannot be run in this cycle. * If the scheduler itself sends a modify job request, * no need to delay the job until next cycle. */ if ((psched == NULL) && (scheduler_jobs_stat) && (job_attr_def[i].at_flags & ATR_DFLAG_SCGALT)) add_to_am_list = 1; /* Is the attribute modifiable in RUN state ? */ if (i < 0) { reply_badattr(PBSE_NOATTR, 1, plist, preq); return; } if ((running == 1) && ((job_attr_def[i].at_flags & ATR_DFLAG_ALTRUN) == 0)) { reply_badattr(PBSE_MODATRRUN, 1, plist, preq); return; } if (i == (int)JOB_ATR_resource) { prsd = find_resc_def(svr_resc_def, plist->al_resc, svr_resc_size); if (prsd == 0) { reply_badattr(PBSE_UNKRESC, 1, plist, preq); return; } /* is the specified resource modifiable while */ /* the job is running */ if (running) { if ((prsd->rs_flags & ATR_DFLAG_ALTRUN) == 0) { reply_badattr(PBSE_MODATRRUN, 1, plist, preq); return; } sendmom = 1; } /* should the resource be only in a select spec */ if (prsd->rs_flags & ATR_DFLAG_CVTSLT && !outsideselect && plist->al_atopl.value && plist->al_atopl.value[0]) { /* if "-lresource" is set and has non-NULL value, ** remember as potential bad resource ** if this appears along "select". */ outsideselect = prsd; } } if (strcmp(plist->al_name, ATTR_project) == 0) { mod_project = 1; } else if ((strcmp(plist->al_name, ATTR_runcount) == 0) && ((plist->al_flags & ATR_VFLAG_HOOK) == 0) && (plist->al_value != NULL) && (plist->al_value[0] != '\0') && ((preq->rq_perm & (ATR_DFLAG_MGWR | ATR_DFLAG_OPWR)) == 0) && (atol(plist->al_value) < \ pjob->ji_wattr[(int)JOB_ATR_runcount].at_val.at_long)) { sprintf(log_buffer, "regular user %s@%s cannot decrease '%s' attribute value from %ld to %ld", preq->rq_user, preq->rq_host, ATTR_runcount, pjob->ji_wattr[(int)JOB_ATR_runcount].at_val.at_long, atol(plist->al_value)); log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, LOG_ERR, pjob->ji_qs.ji_jobid, log_buffer); req_reject(PBSE_PERM, 0, preq); return; } plist = (svrattrl *)GET_NEXT(plist->al_link); } if (outsideselect) { presc = find_resc_entry(&pjob->ji_wattr[(int)JOB_ATR_resource], pseldef); if (presc && ((presc->rs_value.at_flags & ATR_VFLAG_DEFLT) == 0)) { /* select is not a default, so reject qalter */ resc_in_err = strdup(outsideselect->rs_name); req_reject(PBSE_INVALJOBRESC, 0, preq); return; } } /* modify the jobs attributes */ bad = 0; plist = (svrattrl *)GET_NEXT(preq->rq_ind.rq_modify.rq_attr); rc = modify_job_attr(pjob, plist, preq->rq_perm, &bad); if (rc) { if (pjob->ji_clterrmsg) reply_text(preq, rc, pjob->ji_clterrmsg); else reply_badattr(rc, bad, plist, preq); return; } /* If certain attributes modified and if in scheduling cycle */ /* then add to list of jobs which cannot be run in this cycle */ if (add_to_am_list) am_jobs_add(pjob); /* see req_runjob() */ /* check if project attribute was requested to be modified to */ /* be the default project value */ if (mod_project && (pjob->ji_wattr[(int)JOB_ATR_project].at_flags & \ ATR_VFLAG_SET)) { if (strcmp(pjob->ji_wattr[(int)JOB_ATR_project].at_val.at_str, PBS_DEFAULT_PROJECT) == 0) { sprintf(log_buffer, msg_defproject, ATTR_project, PBS_DEFAULT_PROJECT); #ifdef NAS /* localmod 107 */ log_event(PBSEVENT_DEBUG4, PBS_EVENTCLASS_JOB, LOG_INFO, pjob->ji_qs.ji_jobid, log_buffer); #else log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, LOG_INFO, pjob->ji_qs.ji_jobid, log_buffer); #endif /* localmod 107 */ } } if (pjob->ji_wattr[(int)JOB_ATR_resource].at_flags & ATR_VFLAG_MODIFY) { presc = find_resc_entry(&pjob->ji_wattr[(int)JOB_ATR_resource], pseldef); if (presc && (presc->rs_value.at_flags & ATR_VFLAG_DEFLT)) { /* changing Resource_List and select is a default */ /* clear "select" so it is rebuilt inset_resc_deflt */ pseldef->rs_free(&presc->rs_value); } } /* Reset any defaults resource limit which might have been unset */ if ((rc = set_resc_deflt((void *)pjob, JOB_OBJECT, NULL)) != 0) { req_reject(rc, 0, preq); return; } /* if job is not running, may need to change its state */ if (pjob->ji_qs.ji_state != JOB_STATE_RUNNING) { svr_evaljobstate(pjob, &newstate, &newsubstate, 0); (void)svr_setjobstate(pjob, newstate, newsubstate); } else { (void)job_save(pjob, SAVEJOB_FULL); } (void)sprintf(log_buffer, msg_manager, msg_jobmod, preq->rq_user, preq->rq_host); log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, LOG_INFO, pjob->ji_qs.ji_jobid, log_buffer); /* if a resource limit changed for a running job, send to MOM */ if (sendmom) { rc = relay_to_mom(pjob, preq, post_modify_req); if (rc) req_reject(rc, 0, preq); /* unable to get to MOM */ return; } reply_ack(preq); }
int attr_atomic_node_set( struct svrattrl *plist, /* list of pbs_attribute modif structs */ pbs_attribute *old, /* unused */ pbs_attribute *new_attr, /* new pbs_attribute array begins here */ attribute_def *pdef, /* begin array definition structs */ int limit, /* number elts in definition array */ int unkn, /* <0 unknown attrib not permitted */ int privil, /* requester's access privileges */ int *badattr) /* return list position wher bad */ { int acc; int index; int listidx; int rc = 0; pbs_attribute temp; listidx = 0; while (plist) { /*Traverse loop for each client entered pbs_attribute*/ listidx++; if ((index = find_attr(pdef, plist->al_name, limit)) < 0) { if (unkn < 0) /*if unknown attr not allowed*/ { rc = PBSE_NOATTR; break; } else index = unkn; /*if unknown attr are allowed*/ } /* The name of the pbs_attribute is in the definitions list*/ /* Now, have we privilege to set the pbs_attribute ? */ /* Check access capabilities specified in the attrdef */ /* against the requestor's privilege level */ acc = (pdef + index)->at_flags & ATR_DFLAG_ACCESS; if ((acc & privil & ATR_DFLAG_WRACC) == 0) { if (privil & ATR_DFLAG_SvWR) { /* from a daemon, just ignore this pbs_attribute */ plist = (struct svrattrl *)GET_NEXT(plist->al_link); continue; } else { /*from user, no write access to pbs_attribute */ rc = PBSE_ATTRRO; break; } } /*decode new value*/ clear_attr(&temp, pdef + index); if ((rc = (pdef + index)->at_decode(&temp, plist->al_name, plist->al_resc, plist->al_value,0) != 0)) { if ((rc == PBSE_UNKRESC) && (unkn > 0)) rc = 0; /*ignore the "error"*/ else break; } /*update "new" with "temp", MODIFY is set on "new" if changed*/ (new_attr + index)->at_flags &= ~ATR_VFLAG_MODIFY; if ((plist->al_op != INCR) && (plist->al_op != DECR) && (plist->al_op != SET) && (plist->al_op != INCR_OLD)) plist->al_op = SET; if (temp.at_flags & ATR_VFLAG_SET) { /* "temp" has a data value, use it to update "new" */ if ((rc = (pdef + index)->at_set(new_attr + index, &temp, plist->al_op)) != 0) { (pdef + index)->at_free(&temp); break; } } else if (temp.at_flags & ATR_VFLAG_MODIFY) { (pdef + index)->at_free(new_attr + index); (new_attr + index)->at_flags |= ATR_VFLAG_MODIFY; } (pdef + index)->at_free(&temp); plist = (struct svrattrl *)GET_NEXT(plist->al_link); } if (rc != 0) { /*"at_free" functions get invoked by upstream caller*/ /*invoking attr_atomic_kill() on the array of */ /*node-pbs_attribute structs-- any hanging structs are */ /*freed and then the node-pbs_attribute array is freed */ *badattr = listidx; /*the svrattrl that gave a problem*/ } return (rc); }
int line_area(struct Map_info *In, int *field, struct Map_info *Tmp, struct Map_info *Out, struct field_info *Fi, dbDriver * driver, int operator, int *ofield, ATTRIBUTES * attr, struct ilist *BList) { int line, nlines, ncat; struct line_pnts *Points; struct line_cats *Cats, *ACats, *OCats; char buf[1000]; dbString stmt; Points = Vect_new_line_struct(); Cats = Vect_new_cats_struct(); ACats = Vect_new_cats_struct(); OCats = Vect_new_cats_struct(); db_init_string(&stmt); G_message(_("Breaking lines...")); Vect_break_lines_list(Tmp, NULL, BList, GV_LINE | GV_BOUNDARY, NULL); /* G_message(_("Merging lines...")); Vect_merge_lines(Tmp, GV_LINE, NULL, NULL); */ nlines = Vect_get_num_lines(Tmp); /* Warning!: cleaning process (break) creates new vertices which are usually slightly * moved (RE), to compare such new vertex with original input is a problem? * * TODO?: would it be better to copy centroids also and query output map? */ /* Check if the line is inside or outside binput area */ G_message(_("Selecting lines...")); ncat = 1; for (line = 1; line <= nlines; line++) { int ltype; G_percent(line, nlines, 1); /* must be before any continue */ if (!Vect_line_alive(Tmp, line)) continue; ltype = Vect_get_line_type(Tmp, line); if (ltype == GV_BOUNDARY) { /* No more needed */ continue; } /* Now the type should be only GV_LINE */ /* Decide if the line is inside or outside the area. In theory: * 1) All vertices outside * - easy, first vertex must be outside * 2) All vertices inside * 3) All vertices on the boundary, we take it as inside (attention, * result of Vect_point_in_area() for points on segments between vertices may be both * inside or outside, because of representation of numbers) * 4) One or two end vertices on the boundary, all others outside * 5) One or two end vertices on the boundary, all others inside * */ /* Note/TODO: the test done is quite simple, check the point in the middle of segment. * If the line overlaps the boundary, the result may be both outside and inside * this should be solved (check angles?) * This should not happen if Vect_break_lines_list() works correctly */ /* merge here */ merge_line(Tmp, line, Points, Cats); G_debug(3, "line = %d", line); point_area(&(In[1]), field[1], (Points->x[0] + Points->x[1]) / 2, (Points->y[0] + Points->y[1]) / 2, ACats); if ((ACats->n_cats > 0 && operator == OP_AND) || (ACats->n_cats == 0 && operator == OP_NOT)) { int i; /* Point is inside */ G_debug(3, "OK, write line, line ncats = %d area ncats = %d", Cats->n_cats, ACats->n_cats); Vect_reset_cats(OCats); if (ofield[0] > 0) { /* rewrite with all combinations of acat - bcat (-1 in cycle for null) */ for (i = -1; i < Cats->n_cats; i++) { /* line cats */ int j; if (i == -1 && Cats->n_cats > 0) continue; /* no need to make null */ for (j = -1; j < ACats->n_cats; j++) { if (j == -1 && ACats->n_cats > 0) continue; /* no need to make null */ if (ofield[0] > 0) Vect_cat_set(OCats, ofield[0], ncat); /* Attributes */ if (driver) { ATTR *at; sprintf(buf, "insert into %s values ( %d", Fi->table, ncat); db_set_string(&stmt, buf); /* cata */ if (i >= 0) { if (attr[0].columns) { at = find_attr(&(attr[0]), Cats->cat[i]); if (!at) G_fatal_error(_("Attribute not found")); if (at->values) db_append_string(&stmt, at->values); else db_append_string(&stmt, attr[0].null_values); } else { sprintf(buf, ", %d", Cats->cat[i]); db_append_string(&stmt, buf); } } else { if (attr[0].columns) { db_append_string(&stmt, attr[0].null_values); } else { sprintf(buf, ", null"); db_append_string(&stmt, buf); } } /* catb */ if (j >= 0) { if (attr[1].columns) { at = find_attr(&(attr[1]), ACats->cat[j]); if (!at) G_fatal_error(_("Attribute not found")); if (at->values) db_append_string(&stmt, at->values); else db_append_string(&stmt, attr[1].null_values); } else { sprintf(buf, ", %d", ACats->cat[j]); db_append_string(&stmt, buf); } } else { if (attr[1].columns) { db_append_string(&stmt, attr[1].null_values); } else { sprintf(buf, ", null"); db_append_string(&stmt, buf); } } db_append_string(&stmt, " )"); G_debug(3, "%s", db_get_string(&stmt)); if (db_execute_immediate(driver, &stmt) != DB_OK) G_warning(_("Unable to insert new record: '%s'"), db_get_string(&stmt)); } ncat++; } } } /* Add cats from input vectors */ if (ofield[1] > 0 && field[0] > 0) { for (i = 0; i < Cats->n_cats; i++) { if (Cats->field[i] == field[0]) Vect_cat_set(OCats, ofield[1], Cats->cat[i]); } } if (ofield[2] > 0 && field[1] > 0 && ofield[1] != ofield[2]) { for (i = 0; i < ACats->n_cats; i++) { if (ACats->field[i] == field[1]) Vect_cat_set(OCats, ofield[2], ACats->cat[i]); } } Vect_write_line(Out, ltype, Points, OCats); } } return 0; }
void req_quejob( struct batch_request *preq) /* ptr to the decoded request */ { char *id = "req_quejob"; char basename[PBS_JOBBASE + 1]; int created_here = 0; int index; char *jid; attribute_def *pdef; job *pj; svrattrl *psatl; int rc; int sock = preq->rq_conn; int IsCheckpoint = 0; /* set basic (user) level access permission */ resc_access_perm = ATR_DFLAG_USWR | ATR_DFLAG_Creat; if (PBSNodeCheckProlog) { check_state(1); mom_server_all_update_stat(); if (internal_state & INUSE_DOWN) { req_reject(PBSE_MOMREJECT,0,preq,NULL,NULL); return; } } if (preq->rq_fromsvr) { /* from another server - accept the extra attributes */ resc_access_perm |= ATR_DFLAG_MGWR | ATR_DFLAG_SvWR | ATR_DFLAG_MOM; jid = preq->rq_ind.rq_queuejob.rq_jid; } else { /* request must be from server */ log_err(errno, id, "request not from server"); req_reject(PBSE_IVALREQ, 0, preq, NULL, "request not received from server"); return; } /* does job already exist, check both old and new jobs */ if ((pj = find_job(jid)) == NULL) { pj = (job *)GET_NEXT(svr_newjobs); while (pj != NULL) { if (!strcmp(pj->ji_qs.ji_jobid, jid)) break; pj = (job *)GET_NEXT(pj->ji_alljobs); } } /* * New job ... * * for MOM - rather than make up a hashname, we use the name sent * to us by the server as an attribute. */ psatl = (svrattrl *)GET_NEXT(preq->rq_ind.rq_queuejob.rq_attr); while (psatl != NULL) { if (!strcmp(psatl->al_name,ATTR_hashname)) { strcpy(basename,psatl->al_value); break; } psatl = (svrattrl *)GET_NEXT(psatl->al_link); } if (pj != NULL) { /* newly queued job already exists */ if (pj->ji_qs.ji_substate == JOB_SUBSTATE_RUNNING) { /* FAILURE - job exists and is running */ log_err(errno,id,"cannot queue new job, job exists and is running"); req_reject(PBSE_JOBEXIST,0,preq,NULL,"job is running"); return; } /* if checkpointed, then keep old and skip rest of process */ if (pj->ji_qs.ji_svrflags & JOB_SVFLG_CHECKPOINT_FILE) { IsCheckpoint = 1; } /* END if (pj->ji_qs.ji_svrflags & JOB_SVFLG_CHECKPOINT_FILE) */ else { /* unlink job from svr_alljobs since it will be placed on newjobs */ delete_link(&pj->ji_alljobs); } } /* END if (pj != NULL) */ else { /* if not already here, allocate job struct */ if ((pj = job_alloc()) == NULL) { /* FAILURE */ req_reject(PBSE_SYSTEM, 0, preq, NULL, "cannot allocate new job structure"); return; } } /* END else (pj != NULL) */ if (IsCheckpoint == 0) { strcpy(pj->ji_qs.ji_jobid,jid); strcpy(pj->ji_qs.ji_fileprefix,basename); pj->ji_modified = 1; pj->ji_qs.ji_svrflags = created_here; pj->ji_qs.ji_un_type = JOB_UNION_TYPE_NEW; } /* decode attributes from request into job structure */ psatl = (svrattrl *)GET_NEXT(preq->rq_ind.rq_queuejob.rq_attr); while (psatl != NULL) { if (IsCheckpoint == 1) { if (strcmp(psatl->al_name,ATTR_checkpoint_name) && strcmp(psatl->al_name,ATTR_v)) { psatl = (svrattrl *)GET_NEXT(psatl->al_link); continue; } } /* identify the attribute by name */ index = find_attr(job_attr_def,psatl->al_name,JOB_ATR_LAST); if (index < 0) { /* FAILURE */ /* didn`t recognize the name */ job_purge(pj); /* CRI - 12/20/2004 */ reply_badattr(PBSE_NOATTR,1,psatl,preq); return; } pdef = &job_attr_def[index]; /* Is attribute not writeable by manager or by a server? */ if ((pdef->at_flags & resc_access_perm) == 0) { /* FAILURE */ job_purge(pj); reply_badattr(PBSE_ATTRRO,1,psatl,preq); return; } /* decode attribute */ if (!strcmp(psatl->al_name,ATTR_v)) { rc = decode_arst_merge( &pj->ji_wattr[index], psatl->al_name, psatl->al_resc, psatl->al_value); } else { rc = pdef->at_decode( &pj->ji_wattr[index], psatl->al_name, psatl->al_resc, psatl->al_value); } if (rc != 0) { /* FAILURE */ /* all errors are fatal for MOM */ job_purge(pj); reply_badattr(rc,1,psatl,preq); return; } if (psatl->al_op == DFLT) { if (psatl->al_resc) { resource *presc; resource_def *prdef; prdef = find_resc_def(svr_resc_def,psatl->al_resc,svr_resc_size); if (prdef == NULL) { job_purge(pj); reply_badattr(rc,1,psatl, preq); return; } presc = find_resc_entry(&pj->ji_wattr[index],prdef); if (presc != NULL) presc->rs_value.at_flags |= ATR_VFLAG_DEFLT; } else { pj->ji_wattr[index].at_flags |= ATR_VFLAG_DEFLT; } } /* END if (psatl->al_op == DFLT) */ psatl = (svrattrl *)GET_NEXT(psatl->al_link); } /* END while (psatl != NULL) */ if (IsCheckpoint == 1) { pj->ji_qs.ji_substate = JOB_SUBSTATE_TRANSIN; if (reply_jobid(preq,pj->ji_qs.ji_jobid,BATCH_REPLY_CHOICE_Queue) == 0) { delete_link(&pj->ji_alljobs); append_link(&svr_newjobs,&pj->ji_alljobs,pj); pj->ji_qs.ji_un_type = JOB_UNION_TYPE_NEW; pj->ji_qs.ji_un.ji_newt.ji_fromsock = sock; pj->ji_qs.ji_un.ji_newt.ji_fromaddr = get_connectaddr(sock); pj->ji_qs.ji_un.ji_newt.ji_scriptsz = 0; /* Per Eric R., req_mvjobfile was giving error in open_std_file, showed up as fishy error message */ if (pj->ji_grpcache != NULL) { free(pj->ji_grpcache); pj->ji_grpcache = NULL; } } else { close_conn(sock); } /* SUCCESS */ return; } /* set remaining job structure elements */ pj->ji_qs.ji_state = JOB_STATE_TRANSIT; pj->ji_qs.ji_substate = JOB_SUBSTATE_TRANSIN; pj->ji_wattr[(int)JOB_ATR_mtime].at_val.at_long = (long)time_now; pj->ji_wattr[(int)JOB_ATR_mtime].at_flags |= ATR_VFLAG_SET; pj->ji_qs.ji_un_type = JOB_UNION_TYPE_NEW; pj->ji_qs.ji_un.ji_newt.ji_fromsock = sock; pj->ji_qs.ji_un.ji_newt.ji_fromaddr = get_connectaddr(sock); pj->ji_qs.ji_un.ji_newt.ji_scriptsz = 0; /* acknowledge the request with the job id */ if (reply_jobid(preq, pj->ji_qs.ji_jobid, BATCH_REPLY_CHOICE_Queue) != 0) { /* reply failed, purge the job and close the connection */ close_conn(sock); job_purge(pj); return; } /* link job into server's new jobs list request */ append_link(&svr_newjobs, &pj->ji_alljobs, pj); return; } /* END req_quejob() */