// Assumes stream points to the first byte of a program header entry. // After this function, stream points to one past the end of the associated // segment. Also, the first 6 words of the p_header will be set. static inline int copy_cur_segment_aux(FILE *stream, unsigned char *mem, size_t memsz) { int retval = 0; struct p_header phdr; if (read_be_words(stream, &phdr.p_type, 6) != 0) { error(0, 0, "couldn't read program header entry."); return ELF_ERROR_IO_ERROR; } switch(phdr.p_type) { case PT_NULL: case PT_NOTE: case PT_MIPS_ABIFLAGS: // Naïvely skip the above. break; case PT_LOAD: retval = copy_segment(stream, &phdr, mem, memsz); break; default: error(0, 0, "unknown program header entry type 0x%x", phdr.p_type); retval = ELF_ERROR_NOT_SUPPORTED; break; } return retval; }
int distdrop ( cell_map *elev, cell_map *dist, cell_map *dir, cell_map *up, cell_map *dw, seg_map *segment_info, move *movements, queue **redo_segments) { int all_done = 1; int **neighbours = new_int_map ( ( int ) sizeof ( movements ), ( int ) sizeof ( movements[0] ), NULL ); elev->fd = Rast_open_old ( elev->name, "" ); elev->type = Rast_get_map_type( elev->fd ); init_seg_map(elev, segment_info); copy_segment(elev, 0); //print_map_with_seg ( elev, segment_info ); while ( all_done ){ // if all_done != 0? continue: break all_done = queue_pixel ( redo_segments, elev, dist, dir, up, dw, segment_info, movements, neighbours); } return 0; }
RndfOverlay * rndf_overlay_new (RndfRouteNetwork * rndf) { RndfOverlay * r = calloc (1, sizeof (RndfOverlay)); r->rndf = rndf; r->waypoint_hash = g_hash_table_new (hash_waypoint_id, equal_waypoint_id); r->lane_hash = g_hash_table_new (hash_lane_id, equal_lane_id); int i; r->num_segments = rndf->num_segments; r->segments = calloc (rndf->num_segments, sizeof (RndfOverlaySegment)); for (i = 0; i < rndf->num_segments; i++) copy_segment (r, r->segments + i, rndf->segments + i); r->num_zones = rndf->num_zones; r->zones = calloc (rndf->num_zones, sizeof (RndfOverlayZone)); for (i = 0; i < rndf->num_zones; i++) copy_zone (r, r->zones + i, rndf->zones + i); r->num_checkpoints = rndf->num_checkpoints; r->checkpoints = calloc (rndf->num_checkpoints, sizeof (RndfOverlayCheckpoint)); for (i = 0; i < rndf->num_checkpoints; i++) copy_checkpoint (r, r->checkpoints + i, rndf->checkpoints + i); g_hash_table_foreach (r->waypoint_hash, add_exits, r); IntersectionState inter_state; memset (&inter_state, 0, sizeof (inter_state)); inter_state.rndf = r; g_hash_table_foreach (r->waypoint_hash, add_segment_cache, &inter_state); g_hash_table_foreach (r->waypoint_hash, add_intersections, &inter_state); g_hash_table_foreach (r->waypoint_hash, add_yields, &inter_state); g_array_free (inter_state.segments_no_stop, TRUE); g_array_free (inter_state.segments_stopline, TRUE); compute_lane_boundary_expectations (r); for (i = 0; i < r->num_segments; i++) compute_lane_change_pointers (r, r->segments + i); // fill in lane hash for (int segidx = 0; segidx < r->num_segments; segidx++) { RndfOverlaySegment *seg = &r->segments[segidx]; for (int laneidx = 0; laneidx < seg->num_lanes; laneidx++) { int32_t *id = malloc(2 * sizeof(int32_t)); id[0] = seg->segment->id; id[1] = seg->lanes[laneidx].lane->id; g_hash_table_insert(r->lane_hash, id, &seg->lanes[laneidx]); } } return r; }
/* Loop through all load commands and dump them. Then write the Mach header. */ static void dump_it (void) { int i; long linkedit_delta = 0; printf ("--- Load Commands written to Output File ---\n"); for (i = 0; i < nlc; i++) switch (lca[i]->cmd) { case LC_SEGMENT: { struct segment_command *scp = (struct segment_command *) lca[i]; if (strncmp (scp->segname, SEG_DATA, 16) == 0) { /* save data segment file offset and segment_command for unrelocate */ if (data_segment_old_fileoff) unexec_error ("cannot handle multiple DATA segments" " in input file"); data_segment_old_fileoff = scp->fileoff; data_segment_scp = scp; copy_data_segment (lca[i]); } else if (strncmp (scp->segname, EMACS_READ_ONLY_SEGMENT, 16) == 0) { copy_emacs_read_only_segment (lca[i]); } else { if (strncmp (scp->segname, SEG_LINKEDIT, 16) == 0) { if (linkedit_delta) unexec_error ("cannot handle multiple LINKEDIT segments" " in input file"); linkedit_delta = curr_file_offset - scp->fileoff; } copy_segment (lca[i]); } } break; case LC_SYMTAB: copy_symtab (lca[i], linkedit_delta); break; case LC_DYSYMTAB: copy_dysymtab (lca[i], linkedit_delta); break; case LC_TWOLEVEL_HINTS: copy_twolevelhints (lca[i], linkedit_delta); break; #ifdef LC_DYLD_INFO case LC_DYLD_INFO: case LC_DYLD_INFO_ONLY: copy_dyld_info (lca[i], linkedit_delta); break; #endif #ifdef LC_FUNCTION_STARTS case LC_FUNCTION_STARTS: #ifdef LC_DATA_IN_CODE case LC_DATA_IN_CODE: #endif #ifdef LC_DYLIB_CODE_SIGN_DRS case LC_DYLIB_CODE_SIGN_DRS: #endif copy_linkedit_data (lca[i], linkedit_delta); break; #endif default: copy_other (lca[i]); break; } if (curr_header_offset > text_seg_lowest_offset) unexec_error ("not enough room for load commands for new __DATA segments"); printf ("%ld unused bytes follow Mach-O header\n", text_seg_lowest_offset - curr_header_offset); mh.sizeofcmds = curr_header_offset - sizeof (struct mach_header); if (!unexec_write (0, &mh, sizeof (struct mach_header))) unexec_error ("cannot write final header contents"); }
void amend_trace(struct Region *aRegion, struct Trace *aTrace, double wdist, double wangle, double wlength, double wturns, struct Trace **rtTrace, struct Trace **dTrace) { struct Item *aItem, *nextItem, *bItem; struct Report *aRep, *nextRep, *newRep; struct CandRoad *newCandRoad; struct Duallist surCells; struct Cell *aCell; struct Point* modifiedPoint; struct Point* pTransVec; if (aTrace == NULL) { *rtTrace = NULL; *dTrace = NULL; return; } printf("Amending Trace: %s ...\n", aTrace->vName); *rtTrace = (struct Trace*) malloc(sizeof(struct Trace)); sprintf((*rtTrace)->vName, "%sa", aTrace->vName); strncpy((*rtTrace)->onRoute, aTrace->onRoute, strlen(aTrace->onRoute)+1); (*rtTrace)->color.integer = aTrace->color.integer + 20; if(aTrace->type == FILE_ORIGINAL_GPS_TAXI) (*rtTrace)->type = FILE_MODIFIED_GPS_TAXI; else (*rtTrace)->type = FILE_MODIFIED_GPS_BUS; duallist_init(&(*rtTrace)->reports); *dTrace = (struct Trace*) malloc(sizeof(struct Trace)); sprintf((*dTrace)->vName, "%sd", aTrace->vName); strncpy((*dTrace)->onRoute, aTrace->onRoute, strlen(aTrace->onRoute)+1); (*dTrace)->color.integer = aTrace->color.integer + 20; (*dTrace)->type = aTrace->type; duallist_init(&(*dTrace)->reports); // my algorithm // 0. initialize trace-v to be zero. // 1. if there still report in the trace, translate the p_ogd to p_trans by vector trace-v, which is the overall translating error stored in the trace // 2. caluculate the translation vector v_i from the p_trans to the perpendicular point to the nearest road // 3. update the trace->v, by adding v_i to it. // 4. let the perpendicular point to be the p_mgd // 5. Iterate to the next report, go to step 1. aItem = aTrace->reports.head; // 0. initialize trace-v to be zero. set_trace_transVec(aTrace, (double)0, (double)0); while(aItem!=NULL) { aTrace->at = aItem; aRep = (struct Report*)aItem->datap; if(aRep->candRoads.head == NULL) { duallist_init(&surCells); surroundings_from_point(&surCells, aRegion, &aRep->gPoint); bItem = surCells.head; while(bItem != NULL) { aCell = (struct Cell*)bItem->datap; if(aCell != NULL) { //add_candidate_roads(aCell, aRep, aTrace->isHeadingValid); modifiedPoint = (struct Point*)malloc(sizeof(struct Point)); pTransVec = get_trace_transVec(aTrace); assert(pTransVec != NULL); modifiedPoint->x = aRep->gPoint.x + pTransVec->x; modifiedPoint->y = aRep->gPoint.y + pTransVec->y; add_candidate_roads_from_modified_point(aCell, aRep, aTrace->isHeadingValid, modifiedPoint); free(modifiedPoint); } bItem = bItem->next; } duallist_destroy(&surCells, NULL); } aRep->onRoad = aRep->candRoads.head; /* nextItem = aItem->next; if(nextItem != NULL) { nextRep = (struct Report*)nextItem->datap; duallist_init(&surCells); surroundings_from_point(&surCells, aRegion, &nextRep->gPoint); bItem = surCells.head; while(bItem != NULL) { aCell = (struct Cell*)bItem->datap; if(aCell != NULL) { //add_candidate_roads(aCell, nextRep, aTrace->isHeadingValid); modifiedPoint = (struct Point*)malloc(sizeof(struct Point)); pTransVec = get_trace_transVec(aTrace); assert(pTransVec!=NULL); modifiedPoint->x = nextRep->gPoint.x + pTransVec->x; modifiedPoint->y = nextRep->gPoint.y + pTransVec->y; add_candidate_roads_from_modified_point(aCell, nextRep, aTrace->isHeadingValid, modifiedPoint); free(modifiedPoint); } bItem = bItem->next; } duallist_destroy(&surCells, NULL); nextRep->onRoad = nextRep->candRoads.head; } */ amend_report(aRegion, aTrace, wdist, wangle, wlength, wturns); if(aRep->onRoad) { newRep = (struct Report*)malloc(sizeof(struct Report)); newRep->fromTrace = *rtTrace; newRep->timestamp = aRep->timestamp; newRep->speed = aRep->speed; newRep->angle = aRep->angle; newRep->state = aRep->state; newRep->msgType = aRep->msgType; newRep->routeLeng = aRep->routeLeng; newRep->gasVol = aRep->gasVol; newRep->errorInfo = aRep->errorInfo; duallist_init(&newRep->candRoads); newCandRoad = (struct CandRoad*)malloc(sizeof(struct CandRoad)); newCandRoad->aRoad = ((struct CandRoad*)aRep->onRoad->datap)->aRoad; copy_segment(&newCandRoad->onSegment, &((struct CandRoad*)aRep->onRoad->datap)->onSegment); duallist_add_to_head(&newRep->candRoads, newCandRoad); newRep->onRoad = newRep->candRoads.head; newRep->onRoadId = newCandRoad->aRoad->id; newRep->onPath = NULL; newRep->gPoint.x = ((struct CandRoad*)aRep->onRoad->datap)->gPoint.x; newRep->gPoint.y = ((struct CandRoad*)aRep->onRoad->datap)->gPoint.y; duallist_add_to_tail(&(*rtTrace)->reports, newRep); } else { newRep = (struct Report*)malloc(sizeof(struct Report)); newRep->fromTrace = aTrace; newRep->timestamp = aRep->timestamp; newRep->speed = aRep->speed; newRep->angle = aRep->angle; newRep->state = aRep->state; newRep->msgType = aRep->msgType; newRep->routeLeng = aRep->routeLeng; newRep->gasVol = aRep->gasVol; newRep->errorInfo = aRep->errorInfo; duallist_init(&newRep->candRoads); newRep->onRoad = NULL; newRep->onRoadId = -1; newRep->onPath = NULL; newRep->gPoint.x = aRep->gPoint.x; newRep->gPoint.y = aRep->gPoint.y; duallist_add_to_tail(&(*dTrace)->reports, newRep); } if(aItem->prev != aTrace->reports.head) duallist_destroy(&((struct Report*)aItem->prev->datap)->candRoads, free); aItem = aItem->next; } }
static int pickup_copy(VSTREAM *qfile, VSTREAM *cleanup, PICKUP_INFO *info, VSTRING *buf) { time_t now = time((time_t *) 0); int status; char *name; /* * Protect against time-warped time stamps. Warn about mail that has been * queued for an excessive amount of time. Allow for some time drift with * network clients that mount the maildrop remotely - especially clients * that can't get their daylight savings offsets right. */ #define DAY_SECONDS 86400 #define HOUR_SECONDS 3600 if (info->st.st_mtime > now + 2 * HOUR_SECONDS) { msg_warn("%s: message dated %ld seconds into the future", info->id, (long) (info->st.st_mtime - now)); info->st.st_mtime = now; } else if (info->st.st_mtime < now - DAY_SECONDS) { msg_warn("%s: message has been queued for %d days", info->id, (int) ((now - info->st.st_mtime) / DAY_SECONDS)); } /* * Add content inspection transport. See also postsuper(1). */ if (*var_filter_xport) rec_fprintf(cleanup, REC_TYPE_FILT, "%s", var_filter_xport); /* * Copy the message envelope segment. Allow only those records that we * expect to see in the envelope section. The envelope segment must * contain an envelope sender address. */ if ((status = copy_segment(qfile, cleanup, info, buf, REC_TYPE_ENVELOPE)) != 0) return (status); if (info->sender == 0) { msg_warn("%s: uid=%ld: no envelope sender", info->id, (long) info->st.st_uid); return (REMOVE_MESSAGE_FILE); } /* * For messages belonging to $mail_owner also log the maildrop queue id. * This supports message tracking for mail requeued via "postsuper -r". */ #define MAIL_IS_REQUEUED(info) \ ((info)->st.st_uid == var_owner_uid && ((info)->st.st_mode & S_IROTH) == 0) if (MAIL_IS_REQUEUED(info)) { msg_info("%s: uid=%d from=<%s> orig_id=%s", info->id, (int) info->st.st_uid, info->sender, ((name = strrchr(info->path, '/')) != 0 ? name + 1 : info->path)); } else { msg_info("%s: uid=%d from=<%s>", info->id, (int) info->st.st_uid, info->sender); } /* * Message content segment. Send a dummy message length. Prepend a * Received: header to the message contents. For tracing purposes, * include the message file ownership, without revealing the login name. */ rec_fputs(cleanup, REC_TYPE_MESG, ""); rec_fprintf(cleanup, REC_TYPE_NORM, "Received: by %s (%s, from userid %ld)", var_myhostname, var_mail_name, (long) info->st.st_uid); rec_fprintf(cleanup, REC_TYPE_NORM, "\tid %s; %s", info->id, mail_date(info->st.st_mtime)); /* * Copy the message content segment. Allow only those records that we * expect to see in the message content section. */ if ((status = copy_segment(qfile, cleanup, info, buf, REC_TYPE_CONTENT)) != 0) return (status); /* * Send the segment with information extracted from message headers. * Permit a non-empty extracted segment, so that list manager software * can to output recipients after the message, and so that sysadmins can * re-inject messages after a change of configuration. */ rec_fputs(cleanup, REC_TYPE_XTRA, ""); if ((status = copy_segment(qfile, cleanup, info, buf, REC_TYPE_EXTRACT)) != 0) return (status); /* * There are no errors. Send the end-of-data marker, and get the cleanup * service completion status. XXX Since the pickup service is unable to * bounce, the cleanup service can report only soft errors here. */ rec_fputs(cleanup, REC_TYPE_END, ""); if (attr_scan(cleanup, ATTR_FLAG_MISSING, RECV_ATTR_INT(MAIL_ATTR_STATUS, &status), RECV_ATTR_STR(MAIL_ATTR_WHY, buf), ATTR_TYPE_END) != 2) return (cleanup_service_error(info, CLEANUP_STAT_WRITE)); /* * Depending on the cleanup service completion status, delete the message * file, or try again later. Bounces are dealt with by the cleanup * service itself. The master process wakes up the cleanup service every * now and then. */ if (status) { return (cleanup_service_error_reason(info, status, vstring_str(buf))); } else { return (REMOVE_MESSAGE_FILE); } }