/*
* get_toc_byte_sex() guesses the byte sex of the table of contents of the
* library mapped in at the address, addr, of size, size based on the first
* object file's bytesex. If it can't figure it out, because the library has
* no object file members or is malformed it will return UNKNOWN_BYTE_SEX.
*/
__private_extern__
enum byte_sex
get_toc_byte_sex(
char *addr,
uint32_t size)
{
uint32_t magic;
uint32_t ar_name_size;
struct ar_hdr *ar_hdr;
char *p;
ar_hdr = (struct ar_hdr *)(addr + SARMAG);
p = addr + SARMAG + sizeof(struct ar_hdr) +
rnd(strtoul(ar_hdr->ar_size, NULL, 10), sizeof(short));
while(p + sizeof(struct ar_hdr) + sizeof(uint32_t) < addr + size){
ar_hdr = (struct ar_hdr *)p;
if(strncmp(ar_hdr->ar_name, AR_EFMT1, sizeof(AR_EFMT1) - 1) == 0)
ar_name_size = strtoul(ar_hdr->ar_name + sizeof(AR_EFMT1) - 1,
NULL, 10);
else
ar_name_size = 0;
p += sizeof(struct ar_hdr);
memcpy(&magic, p + ar_name_size, sizeof(uint32_t));
if(magic == MH_MAGIC || magic == MH_MAGIC_64)
return(get_host_byte_sex());
else if(magic == SWAP_INT(MH_MAGIC) ||
magic == SWAP_INT(MH_MAGIC_64))
return(get_host_byte_sex() == BIG_ENDIAN_BYTE_SEX ?
LITTLE_ENDIAN_BYTE_SEX : BIG_ENDIAN_BYTE_SEX);
p += rnd(strtoul(ar_hdr->ar_size, NULL, 10), sizeof(short));
}
return(UNKNOWN_BYTE_SEX);
}
static
void
swap_objc_image_info(
struct objc_image_info *o,
enum byte_sex target_byte_sex)
{
o->version = SWAP_INT(o->version);
o->flags = SWAP_INT(o->flags);
}
static
void
swap_objc_property(
struct objc_property *op,
enum byte_sex target_byte_sex)
{
op->name = SWAP_INT(op->name);
op->attributes = SWAP_INT(op->attributes);
}
static
void
swap_objc_property_list(
struct objc_property_list *pl,
enum byte_sex target_byte_sex)
{
pl->entsize = SWAP_INT(pl->entsize);
pl->count = SWAP_INT(pl->count);
}
static
void
swap_ivar_list_t(
struct ivar_list_t *il,
enum byte_sex target_byte_sex)
{
il->entsize = SWAP_INT(il->entsize);
il->count = SWAP_INT(il->count);
}
static
void
swap_method_list_t(
struct method_list_t *ml,
enum byte_sex target_byte_sex)
{
ml->entsize = SWAP_INT(ml->entsize);
ml->count = SWAP_INT(ml->count);
}
static
void
swap_message_ref(
struct message_ref *mr,
enum byte_sex target_byte_sex)
{
mr->imp = SWAP_INT(mr->imp);
mr->sel = SWAP_INT(mr->sel);
}
static
void
swap_method_t(
struct method_t *m,
enum byte_sex target_byte_sex)
{
m->name = SWAP_INT(m->name);
m->types = SWAP_INT(m->types);
m->imp = SWAP_INT(m->imp);
}
static
void
swap_ivar_t(
struct ivar_t *i,
enum byte_sex target_byte_sex)
{
i->offset = SWAP_INT(i->offset);
i->name = SWAP_INT(i->name);
i->type = SWAP_INT(i->type);
i->alignment = SWAP_INT(i->alignment);
i->size = SWAP_INT(i->size);
}
static
void
swap_class_t(
struct class_t *c,
enum byte_sex target_byte_sex)
{
c->isa = SWAP_INT(c->isa);
c->superclass = SWAP_INT(c->superclass);
c->cache = SWAP_INT(c->cache);
c->vtable = SWAP_INT(c->vtable);
c->data = SWAP_INT(c->data);
}
static PyObject *
i_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
{
long val;
int field;
if (get_long(value, &val) < 0)
return NULL;
memcpy(&field, ptr, sizeof(field));
field = SWAP_INT(field);
field = SET(field, (int)val, size);
field = SWAP_INT(field);
memcpy(ptr, &field, sizeof(field));
_RET(value);
}
static
void
swap_protocol_list_t(
struct protocol_list_t *pl,
enum byte_sex target_byte_sex)
{
pl->count = SWAP_INT(pl->count);
}
static
void
swap_class_ro_t(
struct class_ro_t *cro,
enum byte_sex target_byte_sex)
{
cro->flags = SWAP_INT(cro->flags);
cro->instanceStart = SWAP_INT(cro->instanceStart);
cro->instanceSize = SWAP_INT(cro->instanceSize);
cro->ivarLayout = SWAP_INT(cro->ivarLayout);
cro->name = SWAP_INT(cro->name);
cro->baseMethods = SWAP_INT(cro->baseMethods);
cro->baseProtocols = SWAP_INT(cro->baseProtocols);
cro->ivars = SWAP_INT(cro->ivars);
cro->weakIvarLayout = SWAP_INT(cro->weakIvarLayout);
cro->baseProperties = SWAP_INT(cro->baseProperties);
}
static PyObject *
i_get_sw(void *ptr, Py_ssize_t size)
{
int val;
memcpy(&val, ptr, sizeof(val));
val = SWAP_INT(val);
GET_BITFIELD(val, size);
return PyInt_FromLong(val);
}
static PyObject *
I_get_sw(void *ptr, Py_ssize_t size)
{
unsigned int val;
memcpy(&val, ptr, sizeof(val));
val = SWAP_INT(val);
GET_BITFIELD(val, size);
return PyLong_FromUnsignedLong(val);
}
static PyObject *
I_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
{
unsigned long val;
unsigned int field;
if (get_ulong(value, &val) < 0)
return NULL;
memcpy(&field, ptr, sizeof(field));
field = (unsigned int)SET(field, (unsigned int)val, size);
field = SWAP_INT(field);
memcpy(ptr, &field, sizeof(field));
_RET(value);
}
void selectPostTool(int x, int y)
{
switch(shape.type)
{
case SELECT_RECTANGLE:
{
if(shape.x1 > shape.x2) SWAP_INT(shape.x1, shape.x2);
if(shape.y1 > shape.y2) SWAP_INT(shape.y1, shape.y2);
shape.w = shape.x2 - shape.x1;
shape.h = shape.y2 - shape.y1;
shape.type = SELECTED_RECTANGLE;
}
break;
case SELECTED_RECTANGLE:
{
RESET_SHAPE();
}
break;
}
}
static
void
swap_protocol_t(
struct protocol_t *p,
enum byte_sex target_byte_sex)
{
p->isa = SWAP_INT(p->isa);
p->name = SWAP_INT(p->name);
p->protocols = SWAP_INT(p->protocols);
p->instanceMethods = SWAP_INT(p->instanceMethods);
p->classMethods = SWAP_INT(p->classMethods);
p->optionalInstanceMethods = SWAP_INT(p->optionalInstanceMethods);
p->optionalClassMethods = SWAP_INT(p->optionalClassMethods);
p->instanceProperties = SWAP_INT(p->instanceProperties);
}
void do_smartsel (GtkWidget *widget, gpointer data)
{
int i;
float linamp= (float)pow(10., (double)(sdata->tres/20.));
float amp, ampsum=0., rmspow, max_peak=0.;
int x, temp;
if(sdata->from > sdata->to) {
SWAP_INT(sdata->from,sdata->to)
}
set_selection(h.viewstart, h.viewend,0,main_graph->allocation.width,
main_graph->allocation.width);
vertex1=0; vertex2=1; //something IS selected
//set_avec(selection.to - selection.from);
for(i=0; i<(int)atshed.par; i++) selected[i]=FALSE; //unselect all
for(i=sdata->from; i < sdata->to+1; i+=sdata->step) {
if(i >(int)atshed.par-1 || i >(int)sdata->to) break;
for(x=h.viewstart; x < h.viewend; x++) { //amplitude evaluation
amp =ats_sound->amp[i][x];
switch(sdata->met) {
case 0: //peak
if(amp > max_peak) max_peak=amp;
break;
case 1: //RMS POW
ampsum+= amp*amp;
break;
}
}
switch(sdata->met) {
case 0: //peak
if(max_peak >= linamp) selected[i]=TRUE;
break;
case 1: //RMS POW
rmspow= (float)sqrt((double)ampsum / (double)h.diff );
if(rmspow >= linamp) selected[i]=TRUE;
break;
}
ampsum=max_peak=0.;
}
draw_pixm();
gtk_widget_destroy (GTK_WIDGET (data));
}
int chunk_get_ints_endian_safe(Chunk* chunk, int* result, int nb) {
int i = 0;
int *src = (int*) (chunk->content + chunk->nb);
int size = sizeof(int);
if ((chunk->nb + (size * nb)) <= chunk->max) {
for (i = 0; i < nb; i++) {
result[i] = SWAP_INT(src[i]);
}
chunk->nb += (nb * size);
return 0;
}
printf("error in chunk_get_ints_endian_safe !\n");
on_error();
return 1;
}
static
void
swap_category_t(
struct category_t *c,
enum byte_sex target_byte_sex)
{
c->name = SWAP_INT(c->name);
c->cls = SWAP_INT(c->cls);
c->instanceMethods = SWAP_INT(c->instanceMethods);
c->classMethods = SWAP_INT(c->classMethods);
c->protocols = SWAP_INT(c->protocols);
c->instanceProperties = SWAP_INT(c->instanceProperties);
}
int chunk_add_ints_endian_safe(Chunk* chunk, int* ptr, int nb) {
int i = 0;
int *dest;
int size = sizeof(int);
int r = 0;
if (chunk->max < (chunk->nb + (nb * size))) {
r = chunk_size_up (chunk, (nb * size));
if (r < 0) {
printf("error in chunk_add_ints_endian_safe !\n");
on_error();
return 1;
}
}
dest = (int*) (chunk->content + chunk->nb);
for (i = 0; i < nb; i++) {
dest[i] = SWAP_INT(ptr[i]);
}
chunk->nb += (nb * size);
return 0;
}
int matout(char *fullname,char *varname,void *data,int nrows,int ncols,char vartype, char *mode, char endianess)
{
int size;
long nelem;
int type,namelen;
int mrows,mcols,imagf;
int i;
FILE *fs;
mrows = nrows;
mcols = ncols;
nelem = mrows*mcols;
switch (vartype) {
case 'd': /* 8-byte doubles */
type=00;
size=8;
double *vard=data;
if (endianess=='B') { for (i=0;i<nelem;i++) SWAP_DOUBLE(vard[i]); };
break;
case 'r': /* 4-byte reals */
type=10;
size=4;
float *varf=data;
if (endianess=='B') { for (i=0;i<nelem;i++) SWAP_FLOAT(varf[i]); };
break;
case 'l': /* 4-byte int, row-wise */
type=20;
size=4;
int *varl=data;
if (endianess=='B') { for (i=0;i<nelem;i++) SWAP_INT(varl[i]); };
break;
case 's': /* 2-byte signed shorts */
type=30;
size=2;
short *vars=data;
if (endianess=='B') { for (i=0;i<nelem;i++) SWAP_SHORT(vars[i]); };
break;
case 'u': /* 2-byte unsigned shorts */
type=40;
size=2;
short *varus=data;
if (endianess=='B') { for (i=0;i<nelem;i++) SWAP_SHORT(varus[i]); };
break;
// case 't': /* 2-byte unsigned shorts saved as "text" */
// type=41;
// nbytes = mrows*mcols*2;
case 't': /* 1-byte unsigned shorts saved as "text" */
type=51;
size=1;
break;
case 'b': /* 1-byte unsigned chars */
case 'c': /* 1-byte signed chars */
type=50;
size=1;
break;
default:
return (-1);
}
if (disable_disk_writing) return (0);
for (i=0 ; i<nfiles ; i++) {
if (! *matfile[i]) break;
if (!strcmp(fullname,matfile[i])) break;
}
if (i<nfiles) {
fs = fd[i];
} else {
fs = NULL;
}
if (fs == NULL) {
if ((fs=fopen(fullname,mode))==NULL) {
sprintf(message,"%s could not be opened because of reason %d",fullname,errno);;
warn(message);
return (-1);
}
strcpy(matfile[i],fullname);
fd[i] = fs;
if ((i==nfiles) && (nfiles<MAXFILES-1)) nfiles++;
}
imagf=0;
if (endianess=='B') SWAP_INT(type);
if (fwrite(&type,sizeof(int),1,fs) != 1) {
writerr();
return (-1);
}
if (endianess=='B') SWAP_INT(mrows);
if (fwrite(&mrows,sizeof(int),1,fs) != 1) {
writerr();
return (-1);
}
if (endianess=='B') SWAP_INT(mcols);
if (fwrite(&mcols,sizeof(int),1,fs) != 1) {
writerr();
return (-1);
}
if (endianess=='B') SWAP_INT(imagf);
if (fwrite(&imagf,sizeof(int),1,fs) != 1) {
writerr();
return (-1);
}
namelen=strlen(varname)+1;
if (endianess=='B') SWAP_INT(namelen);
if (fwrite(&namelen,sizeof(int),1,fs) != 1) {
writerr();
return (-1);
}
if (endianess=='B') SWAP_INT(namelen);
if (fwrite(varname,(unsigned int)namelen,1,fs) != 1) {
writerr();
return (-1);
}
if (fwrite(data,size,nelem,fs) != nelem) {
writerr();
return (-1);
}
matclose(fullname);
return (0);
}
void matscan(FILE *fs, int maxVarsToSearch, int returnString)
{
int info[5];
long i;
long fileptr,tfileptr,tfp;
long nbyt=0,nelem,skip;
int type;
int mrows,mcols;
int imagf;
int namelen;
long varNumber = 0;
char varname[80];
char *stype="";
int varnum=0;
Array *a= PushDataBlock(NewArray(&stringStruct, (Dimension *)0));
long extra=1;
fileptr = ftell(fs);
if (DEBUG) printf("Entering matscan\n");
while (1) {
tfileptr = ftell(fs);
if (DEBUG) printf("at address %ld \n",tfileptr);
if (fread(info,4,5,fs)==5) {
if (info[4] & 0xffff0000) { // convert header from little endian to big indian
// info[0] changed to info[4] 2006/3/15 as double type can be 0, hence
// no way to know big from little endian info[0] for doubles.
if (DEBUG) printf("swapping!\n");
for (i=0;i<5;i++) SWAP_INT(info[i]);
}
info[0] = info[0]%1000;
tfp = ftell(fs);
if (DEBUG) printf("at address %ld \n",tfp);
if (DEBUG) printf("info = %d %d %d %d %d\n",info[0],info[1],info[2],info[3],info[4]);
type = info[0]%1000;
if ((namelen = info[4])<80L) {
if (fread(varname,1,info[4],fs)==(int)info[4]) {
if (type==0) {
// 8-byte doubles
stype=p_strcpy("double*8"); nbyt=8;
} else if (type==10) {
// 4-byte reals
stype=p_strcpy("real*4 "); nbyt=4;
} else if ((type==120) || (type==20)) {
// 4-byte int
stype=p_strcpy("int*4 "); nbyt=4;
} else if (type==30) {
// 2-byte signed (30) shorts
stype=p_strcpy("short*2 "); nbyt=2;
} else if (type==40) {
// 2-byte unsigned (40) shorts
stype=p_strcpy("ushort*2"); nbyt=2;
} else if ((type==50) || (type==51)) {
// 1-byte signed or unsigned chars (50) or text (51)
stype=p_strcpy("char*1 "); nbyt=1;
} else {
sprintf(message,"Unknown data type %d",type);
YError(message);
}
if (returnString) {
if (varnum!=0) a= PushDataBlock((void *)GrowArray(a, extra));
a->value.q[varnum] = p_malloc(81);
sprintf(a->value.q[varnum],"%30s %s array [%d,%d]",varname, \
stype,info[1],info[2]);
varnum++;
} else {
printf("%30s %s array [%d,%d]\n",varname,stype,info[1],info[2]);
}
mrows=info[1];
mcols=info[2];
nelem=mrows*mcols;
imagf=info[3];
if (imagf) nbyt=2*nbyt;
skip = nbyt*nelem;
if (DEBUG) printf("skiping data part: %ld bytes\n",skip);
if (skip) fseek(fs,nbyt*nelem,SEEK_CUR);
}
}
} else {
break;
}
if (maxVarsToSearch) {
if (++varNumber >= maxVarsToSearch) {
break;
}
}
}
}
// This routine searches for the existence of "var"
// The search can be limited to the next "maxVarsToSearch" by setting maxVarsToSearch>0
int matfind(FILE *fs, char *var, int maxVarsToSearch)
{
int info[5];
long i;
long fileptr,tfileptr,tfp;
long nbyt,nelem,skip;
long rest,prec;
int type,mrows,mcols;
int imagf;
int namelen;
long varNumber = 0;
char varname[80];
char string[200];
if (*var=='*') return (1); // requested variable name matches any array name
fileptr = ftell(fs);
if (DEBUG) printf("Entering matfind\n");
while (1) {
tfileptr = ftell(fs);
if (DEBUG) printf("at address %ld \n",tfileptr);
if (fread(info,4,5,fs)==5) {
if (info[4] & 0xffff0000) { // convert header from big endian to little indian
// info[0] changed to info[4] 2006/3/15 as double type can be 0, hence
// no way to know big from little endian info[0] for doubles.
if (DEBUG) printf("swapping!\n");
for (i=0;i<5;i++) SWAP_INT(info[i]);
}
info[0] = info[0]%1000;
tfp = ftell(fs);
if (DEBUG) printf("at address %ld \n",tfp);
if (DEBUG) printf("info = %d %d %d %d %d\n",info[0],info[1],info[2],info[3],info[4]);
if ((namelen = info[4])<80L) {
if (fread(varname,1,info[4],fs)==(int)info[4]) {
if (DEBUG) printf("variable name: %s\n",varname);
if (matchvarname(varname,var)) { // success if a (possibly wildcard in "var") match
fseek(fs,tfileptr,SEEK_SET);
return (1);
} else {
type = *info - 10*(*info/10);
rest = (*info - type)/10;
prec = rest - 10*(rest/10);
switch (prec) {
case 0: nbyt = 8; break;
case 1: nbyt = 4; break;
case 2: nbyt = 4; break;
case 3: nbyt = 2; break;
case 4: nbyt = 2; break;
case 5: nbyt = 1; break;
default:
sprintf(string,"Precision specification not available");
warn(string);
fseek(fs,fileptr,SEEK_SET);
return (0);
}
mrows=info[1];
mcols=info[2];
nelem=mrows*mcols;
imagf=info[3];
if (imagf) nbyt=2*nbyt;
skip = nbyt*nelem;
if (DEBUG) printf("skiping %ld bytes\n",skip);
if (skip) fseek(fs,nbyt*nelem,SEEK_CUR);
}
}
}
} else {
break;
}
if (maxVarsToSearch) {
if (++varNumber >= maxVarsToSearch) {
break;
}
}
}
//lseek(fh,fileptr,SEEK_SET);
fseek(fs,fileptr,SEEK_SET);
return(0);
}
void Y_ml4read(int nArgs)
{
char *filename="";
char *varname="";
int leave_open = 0;
if (nArgs==2) {
filename=YGetString(sp-nArgs+1);
varname=YGetString(sp-nArgs+2);
leave_open = 0;
} else if (nArgs==3) {
filename=YGetString(sp-nArgs+1);
varname=YGetString(sp-nArgs+2);
leave_open=YGetInteger(sp-nArgs+3);
}
unsigned long bytes_read;
int type,namelen;
unsigned long nElements,nBytesToRead;
int mrows,mcols,imagf;
FILE *fs;
int fileptr;
int endian = 'L';
int size=0,i;
fs = openmat(filename);
if (fs == NULL) YError(p_strncat("Can't open file ",filename,0));
if (!matfind(fs,varname,50000)) YError(p_strncat("No Such variable ",varname,0));
fileptr = ftell(fs);
if (DEBUG) printf("@ position %d\n",fileptr);
bytes_read = fread(&type,sizeof(int),1,fs);
if (bytes_read==0) {
matclose(filename);
YError("Premature end of file");; // end of file
}
fread(&mrows,sizeof(int),1,fs);
fread(&mcols,sizeof(int),1,fs);
fread(&imagf,sizeof(int),1,fs);
fread(&namelen,sizeof(int),1,fs);
if (namelen & 0xffff0000) {
if (DEBUG) printf("Big endian file\n");
endian = 'B';
SWAP_INT(type);
SWAP_INT(mrows);
SWAP_INT(mcols);
SWAP_INT(imagf);
SWAP_INT(namelen);
}
type = type%1000;
if (DEBUG) printf("rows,cols,namelen= %d %d %d\n",mrows,mcols,namelen);
if (namelen>255) {
fseek(fs,fileptr,SEEK_SET); // leave file ptr at begginning of this variable
matclose(filename);
YError("Variable name too long!");
}
fread(tempvarname,(unsigned int)namelen,1,fs);
// if ((*varname!='*') && strcmp(varname,tempvarname)) { // error if not same varname
if (!matchvarname(tempvarname,varname)) { // error if not same varname
fseek(fs,fileptr,SEEK_SET); // leave file ptr at begginning of this variable
matclose(filename);
YError(p_strncat("Can't find variable",varname,0));
}
nElements = (unsigned)mrows*(unsigned)mcols;
Dimension *tmp=tmpDims;
tmpDims=0;
FreeDimension(tmp);
if (mrows<=1) {
tmpDims= NewDimension(mcols, 1L, (Dimension *)0);
} else if (mcols<=1) {
tmpDims= NewDimension(mrows, 1L, (Dimension *)0);
} else {
tmpDims= NewDimension(mrows, 1L, (Dimension *)0);
tmpDims= NewDimension(mcols, 1L, tmpDims);
}
if (type==0) {
// 8-byte doubles
size = 8;
Array *a= PushDataBlock(NewArray(&doubleStruct, tmpDims));
double *data = a->value.d;
bytes_read = fread((void *)data,size,nElements,fs);
if (endian=='B') { for (i=0;i<nElements;i++) SWAP_DOUBLE(data[i]); }
} else if (type==10) {
// 4-byte reals
size = 4;
Array *a= PushDataBlock(NewArray(&floatStruct, tmpDims));
float *data = a->value.f;
bytes_read = fread((void *)data,size,nElements,fs);
if (endian=='B') { for (i=0;i<nElements;i++) SWAP_FLOAT(data[i]); }
} else if ((type==120) || (type==20)) {
// 4-byte int
size = 4;
Array *a= PushDataBlock(NewArray(&intStruct, tmpDims));
int *data = a->value.l;
bytes_read = fread((void *)data,size,nElements,fs);
if (endian=='B') { for (i=0;i<nElements;i++) SWAP_INT(data[i]); }
} else if (type==30) {
// 2-byte signed (30) shorts
size = 2;
Array *a= PushDataBlock(NewArray(&shortStruct, tmpDims));
short *data = a->value.s;
bytes_read = fread((void *)data,size,nElements,fs);
if (endian=='B') { for (i=0;i<nElements;i++) SWAP_SHORT(data[i]); }
} else if (type==40) {
// 2-byte unsigned (40) shorts
size = 2;
Array *a= PushDataBlock(NewArray(&shortStruct, tmpDims));
short *data = a->value.s;
Array *b= PushDataBlock(NewArray(&longStruct, tmpDims));
long *data2 = b->value.l;
bytes_read = fread((void *)data,size,nElements,fs);
if (endian=='B') { for (i=0;i<nElements;i++) SWAP_SHORT(data[i]); }
for (i=1;i<=nElements;i++) *(data2++) = (((long)*(data++))|0xFFFF0000)+65535;
} else if (type==50) {
// 1-byte signed or unsigned chars (50)
size = 1;
Array *a= PushDataBlock(NewArray(&charStruct, tmpDims));
char *data = a->value.c;
bytes_read = fread((void *)data,size,nElements,fs);
} else if (type==51) {
// text (51)
size = 1;
Array *a= PushDataBlock(NewArray(&stringStruct, (Dimension *)0));
char *buf;
a->value.q[0] = buf = p_malloc(nElements+1);
if (DEBUG) printf("strlen: %d\n",(int)strlen((void *)a->value.q[0]));
// bytes_read = fread(a->value.q[0],1,nElements,fs);
bytes_read = fread(buf,1,nElements,fs);
*((char *)buf + nElements) = 0; // append a NULL to text string
} else {
matclose(filename);
sprintf(message,"Unknown type %d",type);
YError(message);
}
if (bytes_read!=nElements) {
fseek(fs,nElements*size,SEEK_CUR);
matclose(filename);
if (DEBUG) printf("read:%ld expected:%ld\n",bytes_read,nBytesToRead);
YError("Premature end of file");
}
if (!leave_open) matclose(filename);
}
int CMakeSip::makeReq(int id, PHONE_CFG * cfg, ADDR *addrExt,STR_64 *str64ExtADDR)
{
unsigned int iMeth=0;
unsigned int uiFromLoc=0;
unsigned int uiFromLen=0;
strDstAddr.s=(unsigned char *)&spSes->dstSipAddr.strVal;
strDstAddr.len=(int)spSes->dstSipAddr.uiLen;
if(cfg){
if(strcmp(&cfg->szSipTransport[0],"TLS")==0){iIsTCP=0;iIsTLS=1;}
else if(strcmp(&cfg->szSipTransport[0],"TCP")==0){iIsTCP=1;iIsTLS=0;}
else if(strcmp(&cfg->szSipTransport[0],"UDP")==0){iIsTCP=0;iIsTLS=0;}
else {iIsTCP=0;iIsTLS=0;}
}
char *s=buf;
int iPrevId=spSes->cs.iSendS;
spSes->cs.iSendS=id;
if(id!=METHOD_ACK)
{
if(iPrevId!=spSes->cs.iSendS)
{
if(spSes->cs.iSendS==METHOD_OPTIONS){
spSes->sSendTo.setRetransmit(2,5*T_GT_SECOND);
}
else if(iIsTCP || iIsTLS)
spSes->sSendTo.setRetransmit(7,5*T_GT_SECOND);
else if(spSes->cs.iSendS==METHOD_REGISTER)
spSes->sSendTo.setRetransmit(7,1*T_GT_SECOND);
else if(spSes->cs.iSendS==METHOD_INVITE)
spSes->sSendTo.setRetransmit(7,(cfg==NULL || cfg->iNetworkIsMobile)?(6*T_GT_SECOND):(3*T_GT_SECOND));
else
spSes->sSendTo.setRetransmit();
}
spSes->cs.iWaitS=200;
}
else
{
spSes->cs.iWaitS=0;
}
//TODO getITFromZZ
unsigned int uiCSeq;
#if 1
if(cfg && id==METHOD_REGISTER)
{
if(!cfg->uiSipCSeq){
//next reg should be with greater CSeq, even app restarts, if call-id is same
//problem was with SIP Thor on OpenSIPS XS 1.4.5, but not with FreeSwitch
int get_time();
cfg->uiSipCSeq=(unsigned int)get_time();
cfg->uiSipCSeq-=1000000000;
}
cfg->uiSipCSeq++;
uiCSeq=(unsigned int)cfg->uiSipCSeq;
}
else if(spSes){
if(id!=METHOD_ACK && id!=METHOD_CANCEL)spSes->uiSipCseq++;
uiCSeq=spSes->uiSipCseq;
}
else {
uiCSeq=getTickCount();
while(uiCSeq>1000000000)uiCSeq-=1000000000;
}
#else
static unsigned int ss=User::TickCount();
ss++;
uiCSeq=ss;
#endif
if(!uiCSeq)uiCSeq=1;
int iReplaceRoute=0;
if(iContactId >(int)sMsg->hldContact.uiCount)
iContactId=0;
GET_METH(id,iMeth);
//TODO do we need to send route with cancel msg
#define METHOD_CANCEL_IGNORE 0
struct HOLDER_CONTACT *hc = &sMsg->hldContact;
HLD_ROUTE *hrr = &sMsg->hldRecRoute;
//do i need to check "&& spSes->sSIPMsg.hldRecRoute.uiCount"?
if(hc->uiCount<1 && spSes && spSes->sSIPMsg.hldContact.uiCount && sMsg->sipHdr.dstrStatusCode.uiVal>=300){
hc = &spSes->sSIPMsg.hldContact;
hrr = &spSes->sSIPMsg.hldRecRoute;
}
if(hc->x[iContactId].sipUri.dstrSipAddr.uiLen && (id & (METHOD_CANCEL_IGNORE|METHOD_REGISTER))==0)
{
if(hrr->uiCount)//TODO caller calle
{
iReplaceRoute=!hasRouteLR(hrr,0);
}
if(iReplaceRoute)
{
strDstAddr.s=(unsigned char *)hrr->x[0].sipUri.dstrSipAddr.strVal;
strDstAddr.len=(int)hrr->x[0].sipUri.dstrSipAddr.uiLen;
}
else
{
strDstAddr.s=(unsigned char *)hc->x[iContactId].sipUri.dstrSipAddr.strVal;
strDstAddr.len=(int)hc->x[iContactId].sipUri.dstrSipAddr.uiLen;
}
}
//HDR
ADD_DSTR(s,uiLen,sip_meth[iMeth]); ADD_CHAR(s,uiLen,' ');
ADD_L_STR(s,uiLen,strDstAddr.s, strDstAddr.len);ADD_0_STR(s,uiLen," SIP/2.0\r\n");
switch(id)
{
case METHOD_INVITE:
sMsg->hdrCSeq.dstrID.uiVal=uiCSeq;
break;
case METHOD_ACK:
case METHOD_CANCEL:
uiCSeq=sMsg->hdrCSeq.dstrID.uiVal;
break;
case METHOD_REFER:
// ADD_STR(s,uiLen,"Refer-To: <");
//ADD_DSTR(s,uiLen,spSes->str32Forward);
//ADD_0_STR(s,uiLen,">\r\n");
break;
case METHOD_REGISTER:
if(sMsg->hdrCSeq.dstrID.uiVal)uiCSeq=sMsg->hdrCSeq.dstrID.uiVal+1;//ast
sMsg->hdrCSeq.dstrID.uiVal=uiCSeq;
case METHOD_OPTIONS:
ADD_STR(s,uiLen,"Allow: INVITE,ACK,CANCEL,OPTIONS,MESSAGE,BYE,INFO\r\n");
if(id==METHOD_OPTIONS)
{
ADD_STR(s,uiLen,"Accept: application/sdp, text/plain\r\n");
}
break;
}
//TODO test asterisk add
if((id & METHOD_REGISTER) && cfg && !cfg->reg.bUnReg && cfg->iUseOnlyNatIp==0 && sMsg && sMsg->hldVia.x[0].dstrRecived.uiLen<32)
{
if(sMsg->hldVia.x[0].dstrRecived.strVal && sMsg->hldVia.x[0].dstrRecived.uiLen){
//TODO hi addr
if(str64ExtADDR)
spSes->pIPVisble=str64ExtADDR;
memcpy(spSes->pIPVisble->strVal
,sMsg->hldVia.x[0].dstrRecived.strVal
,sMsg->hldVia.x[0].dstrRecived.uiLen);
spSes->pIPVisble->uiLen=sMsg->hldVia.x[0].dstrRecived.uiLen;
if(sMsg->hldVia.x[0].dstrRPort.uiVal)
spSes->uiUserVisibleSipPort=sMsg->hldVia.x[0].dstrRPort.uiVal;
if(addrExt)
{
addrExt->ip=ipstr2long(sMsg->hldVia.x[0].dstrRecived.uiLen,sMsg->hldVia.x[0].dstrRecived.strVal);
SWAP_INT(addrExt->ip);
addrExt->setPort((unsigned int)spSes->uiUserVisibleSipPort);
}
}
else if(sMsg->hldVia.x[0].dstrRPort.uiVal){
// printf("[reg rport=%d ]",sMsg->hldVia.x[0].dstrRPort.uiVal);
spSes->uiUserVisibleSipPort=sMsg->hldVia.x[0].dstrRPort.uiVal;
addrExt->setPort((unsigned int)spSes->uiUserVisibleSipPort);
}
}
if(iIsTCP)ADD_STR(s,uiLen,"Via: SIP/2.0/TCP ")
else if(iIsTLS)ADD_STR(s,uiLen,"Via: SIP/2.0/TLS ")
else ADD_STR(s,uiLen,"Via: SIP/2.0/UDP ")
ADD_DSTR(s,uiLen,(*spSes->pIPVisble));
if(spSes->uiUserVisibleSipPort!=DEAFULT_SIP_PORT)
uiLen += sprintf(s + uiLen, ":%u", spSes->uiUserVisibleSipPort);
ADD_STR(s,uiLen,";rport");
ADD_STR(s,uiLen,";branch=z9hG4bK");
ADD_L_STR(s,uiLen,sMsg->dstrCallID.strVal,4);
if(id!=METHOD_CANCEL)
{
ADD_L_STR(s,uiLen,s,2);
}
else
{
ADD_STR(s,uiLen,"IN");
}
uiLen += sprintf(s + uiLen, "%u",uiCSeq^0x123);
ADD_CRLF(s,uiLen);
uiLen += sprintf(s + uiLen, "CSeq: %u ", uiCSeq);
ADD_DSTRCRLF(s,uiLen,sip_meth[iMeth])
if((id & (METHOD_REGISTER|METHOD_CANCEL))
|| (spSes->cs.iCaller && (sMsg==NULL || sMsg->hdrCSeq.uiMethodID==0)))
{
ADD_FSTR(s,uiLen,"From: ",6);
{
uiFromLoc=uiLen;
if(cfg->user.nick[0]){
ADD_CHAR(s,uiLen,'"');
ADD_0_STR(s,uiLen,cfg->user.nick);
ADD_CHAR(s,uiLen,'"');
}
uiLen+=sprintf(s+uiLen," <%.*s>",D_STR(spSes->userSipAddr));
uiFromLen=uiLen-uiFromLoc;
if(spSes->str16Tag.uiLen)
{
ADD_0_STR(s,uiLen,";tag=");
ADD_DSTRCRLF(s,uiLen,spSes->str16Tag);
}
else ADD_CRLF(s,uiLen);
}
{
if((sMsg->hdrTo.dstrTag.uiLen==0 && id!=METHOD_REGISTER)
|| (id & METHOD_CANCEL)
)
{
// puts("a4");
ADD_FSTR(s,uiLen,"To: <",5);
//vajag lai straadaatu 3xx vispaar sho laikam jau nevajag,
//jo es jau iedoshu liidzi sMsg kuru saneemu
if(spSes && spSes->sSIPMsg.hdrTo.sipUri.dstrSipAddr.uiLen==0)
{
spSes->sSIPMsg.hdrTo.sipUri.dstrSipAddr.strVal=
(char *)&spSes->sSIPMsg.rawDataBuffer+spSes->sSIPMsg.uiOffset;
ADD_DSTR((char *)&spSes->sSIPMsg.rawDataBuffer, spSes->sSIPMsg.uiOffset,spSes->dstSipAddr);
spSes->sSIPMsg.hdrTo.sipUri.dstrSipAddr.uiLen=spSes->dstSipAddr.uiLen;
//varbuut sho saglabaat pie get new ses
}
if(sMsg->hdrTo.sipUri.dstrSipAddr.strVal)
{
ADD_DSTR(s,uiLen,sMsg->hdrTo.sipUri.dstrSipAddr);
}
else
{
ADD_DSTR(s,uiLen,spSes->dstSipAddr);
}
ADD_FSTR(s,uiLen,">\r\n",3);
// puts("a5");
}
else if (id==METHOD_REGISTER)
{
// DEBUG(0,"make register---------")
ADD_FSTR(s,uiLen,"To: ",4);
memcpy(s+uiLen,s+uiFromLoc,uiFromLen);
uiLen+=uiFromLen;
ADD_CRLF(s,uiLen);
}
else
{
ADD_DSTRCRLF(s,uiLen,sMsg->hdrTo.dstrFullRow);
// puts("a6");
}
}
}
else
{
//TODO use full row
// char *pMeth1;
// char *pMeth2;
DSTR *fromAddr;
DSTR *toAddr;
DSTR *tag;
// puts("a7");
if(sMsg->sipHdr.dstrStatusCode.uiVal)
{
fromAddr=&sMsg->hdrFrom.sipUri.dstrSipAddr;
toAddr=&sMsg->hdrTo.sipUri.dstrSipAddr;
tag=&sMsg->hdrTo.dstrTag;
// puts("a8");
}
else
{
toAddr=&sMsg->hdrFrom.sipUri.dstrSipAddr;
fromAddr=&sMsg->hdrTo.sipUri.dstrSipAddr;
tag=&sMsg->hdrFrom.dstrTag;
// puts("a9");
}
uiLen+=sprintf(s+uiLen,"From: <%.*s>", D_STR(*fromAddr));
if(spSes->str16Tag.uiLen)
{
ADD_0_STR(s,uiLen,";tag=");
ADD_DSTRCRLF(s,uiLen,spSes->str16Tag);
}
else ADD_CRLF(s,uiLen);
uiLen+=sprintf(s+uiLen,"To: <%.*s>", D_STR(*toAddr));
if(tag->uiLen && !fToTagIgnore)
{
ADD_0_STR(s,uiLen,";tag=");
ADD_DSTRCRLF(s,uiLen,(*tag));
}
else ADD_CRLF(s,uiLen);
}
ADD_FSTR(s,uiLen,"Call-ID: ",9);
ADD_DSTRCRLF(s,uiLen,sMsg->dstrCallID);
ADD_STR(s,uiLen,"Max-Forwards: 70\r\n");
if(id==METHOD_REGISTER){
if(cfg && cfg->szUA[0]){
ADD_STR(s,uiLen,"User-Agent: ");
ADD_0_STR(s,uiLen,cfg->szUA);ADD_CRLF(s,uiLen);
}
else{
ADD_STR(s,uiLen,USER_AGENT);
}
}
if(id != METHOD_CANCEL_IGNORE && (hrr->uiCount || iReplaceRoute))//(toMake & (METHOD_BYE |METHOD_ACK)) && ???
{
uiLen+=addRoute(s+uiLen, 255, hrr, "Route: ",
!((sMsg->hdrCSeq.uiMethodID && sMsg->sipHdr.dstrStatusCode.uiVal) ||
(spSes->cs.iCaller && sMsg->hdrCSeq.uiMethodID==0))
,iReplaceRoute, &hc->x[iContactId].sipUri.dstrSipAddr);
}
if(id & (METHOD_INVITE | METHOD_OPTIONS |METHOD_MESSAGE |METHOD_REGISTER|METHOD_REFER|METHOD_SUBSCRIBE|METHOD_PUBLISH|METHOD_UPDATE))
{
//unsigned int uiPos;
if(cfg && cfg->user.nick[0]){
uiLen+=sprintf(s+uiLen,"Contact: \"%s\" <sip:",cfg->user.nick);//sUserCfg.szUserName);
}
else {ADD_STR(s,uiLen,"Contact: <sip:");}
//uiPos=uiLen;
//TODO if register store contact addr and use it until next reg
if(cfg && (cfg->isOnline() || (id & METHOD_REGISTER)))
{
if(*cfg->user.nr)
uiLen+=sprintf(s+uiLen,"%s@",cfg->user.nr);
else if(*cfg->user.un)
uiLen+=sprintf(s+uiLen,"%s@",cfg->user.un);
}
ADD_DSTR(s,uiLen,(*spSes->pIPVisble));
if(spSes->uiUserVisibleSipPort!=DEAFULT_SIP_PORT)
uiLen+=sprintf(s+uiLen,":%u",spSes->uiUserVisibleSipPort);
if(iIsTCP) {ADD_STR(s,uiLen,";transport=tcp>")}else
if(iIsTLS) {ADD_STR(s,uiLen,";transport=tls>")} else
{ ADD_FSTR(s,uiLen,">",1)}
/*
* return an ascii representation of the integral part of the number
* and set fract to be an ascii representation of the fraction part
* the container for the fraction and the integral part or staticly
* declare with fix size
*/
static CWT_CHAR* numtoa(double number, int base, int precision, CWT_CHAR ** fract)
{
register int i, j;
double ip, fp; /* integer and fraction part */
double fraction;
int digits = MAX_INT - 1;
static CWT_CHAR integral_part[MAX_INT];
static CWT_CHAR fraction_part[MAX_FRACT];
double sign;
int ch;
/* taking care of the obvious case: 0.0 */
if (number == 0.) {
integral_part[0] = _T('0');
integral_part[1] = _T('\0');
fraction_part[0] = _T('0');
fraction_part[1] = _T('\0');
return integral_part;
}
/* for negative numbers */
if ((sign = number) < 0.) {
number = -number;
digits--; /* sign consume one digit */
}
fraction = integral(number, &ip);
number = ip;
/* do the integral part */
if ( ip == 0.) {
integral_part[0] = _T('0');
i = 1;
} else {
for ( i = 0; i < digits && number != 0.; ++i) {
number /= base;
fp = integral(number, &ip);
ch = (int)((fp + PRECISION)*base); /* force to round */
integral_part[i] = (ch <= 9) ? ch + _T('0') : ch + _T('a') - 10;
if (! isxdigit(integral_part[i])) /* bail out overflow !! */
break;
number = ip;
}
}
/* Oh No !! out of bound, ho well fill it up ! */
if (number != 0.)
for (i = 0; i < digits; ++i)
integral_part[i] = _T('9');
/* put the sign ? */
if (sign < 0.)
integral_part[i++] = _T('-');
integral_part[i] = _T('\0');
/* reverse every thing */
for ( i--, j = 0; j < i; j++, i--)
SWAP_INT(integral_part[i], integral_part[j]);
/* the fractionnal part */
for (i=0, fp=fraction; precision > 0 && i < MAX_FRACT ; i++, precision-- ) {
fraction_part[i] = (int)((fp + PRECISION)*10. + _T('0'));
if (! isdigit(fraction_part[i])) /* underflow ? */
break;
fp = (fp*10.0) - (double)(long)((fp + PRECISION)*10.);
}
fraction_part[i] = _T('\0');
if (fract != (CWT_CHAR **)0)
*fract = fraction_part;
return integral_part;
}
void test_cu_buildbuffers_tagged(void) {
int i, p, rc;
int errcount;
int *outcount;
int *msgptr;
void **buffers;
MBIt_Board *board; /* mock board */
char *header_byte, *bufptr;
/* requirements of using mock_filter2 as board filter */
assert(TCU_CommSize < MSGCOUNT/2);
assert(MSGCOUNT >= 1000);
/* Test needs at least 4 procs */
if (TCU_CommSize < 4) return;
/* create outcount array */
outcount = (int *)malloc(sizeof(int) * TCU_CommSize);
assert(outcount != NULL);
/* create array of buffer ptrs */
buffers = (void **)malloc(sizeof(void*) * TCU_CommSize);
assert(buffers != NULL);
SET_ALL_NULL(buffers);
/* --- test where all remote procs are readers --- */
/* create board */
board = mock_board_create();
assert(board != NULL);
assert(board->data != NULL);
assert(board->synced_cursor == 0);
assert(board->data->count_current == 0);
/* different filter */
board->filter = &mock_filter2;
/* by default, all remote procs are readers */
mock_board_populate(board, MSGCOUNT);
assert(board->data->count_current == MSGCOUNT);
rc = MBI_CommUtil_TagMessages(board, outcount);
CU_ASSERT_EQUAL_FATAL(rc, MB_SUCCESS);
CU_ASSERT_PTR_NOT_NULL_FATAL(board->tt);
for (p = 0; p < TCU_CommSize; p++)
{
if (p == TCU_CommRank)
{
CU_ASSERT_EQUAL_FATAL(outcount[p], -1);
}
else
{
CU_ASSERT_EQUAL_FATAL(outcount[p], 2);
}
}
rc = MBI_CommUtil_BuildBuffers_Tagged(board, buffers, outcount);
CU_ASSERT_EQUAL(rc, MB_SUCCESS);
for (p = 0; p < TCU_CommSize; p++)
{
if (p == TCU_CommRank)
{
CU_ASSERT_PTR_NULL(buffers[p]);
}
else
{
CU_ASSERT_PTR_NOT_NULL(buffers[p]);
if (buffers[p] != NULL)
{
/* check header */
header_byte = (char *)buffers[p];
CU_ASSERT_EQUAL(*header_byte, ALLZEROS);
/* check buffer content */
bufptr = (char *)(buffers[p]) + 1;
errcount = 0;
for (i = 0; i < outcount[p]; i++)
{
msgptr = (int *)bufptr;
bufptr += board->data->elem_size;
if (*msgptr != p + i) errcount++;
}
CU_ASSERT_EQUAL(errcount, 0);
}
}
}
/* reset */
FREE_EACH_BUFFER(buffers);
mock_board_delete(&board);
/* --- test where only some procs are readers --- */
/* create board */
board = mock_board_create();
assert(board != NULL);
assert(board->data != NULL);
assert(board->synced_cursor == 0);
assert(board->data->count_current == 0);
/* different filter */
board->filter = &mock_filter2;
/* update reader_list */
assert(TCU_CommSize > 3);
board->reader_list[0] = (TCU_CommRank + 1) % TCU_CommSize;
board->reader_list[1] = (TCU_CommRank + 2) % TCU_CommSize;
if (board->reader_list[0] > board->reader_list[1])
{
SWAP_INT(board->reader_list[0], board->reader_list[1], i);
}
board->reader_count = 2;
mock_board_populate(board, MSGCOUNT);
rc = MBI_CommUtil_TagMessages(board, outcount);
CU_ASSERT_EQUAL_FATAL(rc, MB_SUCCESS);
CU_ASSERT_PTR_NOT_NULL_FATAL(board->tt);
for (p = 0; p < TCU_CommSize; p++)
{
if (p == board->reader_list[0] || p == board->reader_list[1] )
{
CU_ASSERT_EQUAL_FATAL(outcount[p], 2);
}
else
{
CU_ASSERT_EQUAL_FATAL(outcount[p], -1);
}
}
rc = MBI_CommUtil_BuildBuffers_Tagged(board, buffers, outcount);
CU_ASSERT_EQUAL(rc, MB_SUCCESS);
for (p = 0; p < TCU_CommSize; p++)
{
if (outcount[p] == -1)
{
CU_ASSERT_PTR_NULL(buffers[p]);
}
else
{
CU_ASSERT_PTR_NOT_NULL(buffers[p]);
if (buffers[p] != NULL)
{
/* check header */
header_byte = (char *)buffers[p];
CU_ASSERT_EQUAL(*header_byte, ALLZEROS);
/* check buffer content */
bufptr = (char *)(buffers[p]) + 1;
errcount = 0;
for (i = 0; i < outcount[p]; i++)
{
msgptr = (int *)bufptr;
bufptr += board->data->elem_size;
if (*msgptr != p + i) errcount++;
}
CU_ASSERT_EQUAL(errcount, 0);
}
}
}
/* reset */
FREE_EACH_BUFFER(buffers);
mock_board_delete(&board);
free(outcount);
free(buffers);
}
enum bool
swap_object_headers(
void *mach_header,
struct load_command *load_commands)
{
unsigned long i;
uint32_t magic, ncmds, sizeofcmds, cmd_multiple;
cpu_type_t cputype;
cpu_subtype_t cpusubtype;
struct mach_header *mh;
struct mach_header_64 *mh64;
enum byte_sex target_byte_sex;
struct load_command *lc, l;
struct segment_command *sg;
struct segment_command_64 *sg64;
struct section *s;
struct section_64 *s64;
struct symtab_command *st;
struct dysymtab_command *dyst;
struct symseg_command *ss;
struct fvmlib_command *fl;
struct thread_command *ut;
struct ident_command *id;
struct dylib_command *dl;
struct sub_framework_command *sub;
struct sub_umbrella_command *usub;
struct sub_library_command *lsub;
struct sub_client_command *csub;
struct prebound_dylib_command *pbdylib;
struct dylinker_command *dyld;
struct routines_command *rc;
struct routines_command_64 *rc64;
struct twolevel_hints_command *hints;
struct prebind_cksum_command *cs;
struct uuid_command *uuid;
struct linkedit_data_command *ld;
struct rpath_command *rpath;
struct encryption_info_command *ec;
struct dyld_info_command *dc;
uint32_t flavor, count;
unsigned long nflavor;
char *p, *state, *cmd_name;
magic = *((uint32_t *)mach_header);
if(magic == MH_MAGIC){
mh = (struct mach_header *)mach_header;
ncmds = mh->ncmds;
sizeofcmds = mh->sizeofcmds;
cputype = mh->cputype;
cpusubtype = mh->cpusubtype;
cmd_multiple = 4;
mh64 = NULL;
}
else{
mh64 = (struct mach_header_64 *)mach_header;
ncmds = mh64->ncmds;
sizeofcmds = mh64->sizeofcmds;
cputype = mh64->cputype;
cpusubtype = mh64->cpusubtype;
cmd_multiple = 8;
mh = NULL;
}
/*
* Make a pass through the load commands checking them to the level
* that they can be parsed and then swapped.
*/
for(i = 0, lc = load_commands; i < ncmds; i++){
l = *lc;
/* check load command size for a correct multiple size */
if(lc->cmdsize % cmd_multiple != 0){
error("in swap_object_headers(): malformed load command %lu "
"(cmdsize not a multiple of %u)", i, cmd_multiple);
return(FALSE);
}
/* check that load command does not extends past end of commands */
if((char *)lc + lc->cmdsize >
(char *)load_commands + sizeofcmds){
error("in swap_object_headers(): truncated or malformed load "
"command %lu (extends past the end of the all load "
"commands)", i);
return(FALSE);
}
/* check that the load command size is not zero */
if(lc->cmdsize == 0){
error("in swap_object_headers(): malformed load command %lu "
"(cmdsize is zero)", i);
return(FALSE);
}
switch(lc->cmd){
case LC_SEGMENT:
sg = (struct segment_command *)lc;
if(sg->cmdsize != sizeof(struct segment_command) +
sg->nsects * sizeof(struct section)){
error("in swap_object_headers(): malformed load command "
"(inconsistent cmdsize in LC_SEGMENT command %lu for "
"the number of sections)", i);
return(FALSE);
}
break;
case LC_SEGMENT_64:
sg64 = (struct segment_command_64 *)lc;
if(sg64->cmdsize != sizeof(struct segment_command_64) +
sg64->nsects * sizeof(struct section_64)){
error("in swap_object_headers(): malformed load command "
"(inconsistent cmdsize in LC_SEGMENT_64 command %lu "
"for the number of sections)", i);
return(FALSE);
}
break;
case LC_SYMTAB:
st = (struct symtab_command *)lc;
if(st->cmdsize != sizeof(struct symtab_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_SYMTAB command %lu has incorrect cmdsize", i);
return(FALSE);
}
break;
case LC_DYSYMTAB:
dyst = (struct dysymtab_command *)lc;
if(dyst->cmdsize != sizeof(struct dysymtab_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_DYSYMTAB command %lu has incorrect cmdsize", i);
return(FALSE);
}
break;
case LC_SYMSEG:
ss = (struct symseg_command *)lc;
if(ss->cmdsize != sizeof(struct symseg_command)){
error("in swap_object_headers(): malformed load command "
"(LC_SYMSEG command %lu has incorrect cmdsize", i);
return(FALSE);
}
break;
case LC_IDFVMLIB:
case LC_LOADFVMLIB:
fl = (struct fvmlib_command *)lc;
if(fl->cmdsize < sizeof(struct fvmlib_command)){
error("in swap_object_headers(): malformed load commands "
"(%s command %lu has too small cmdsize field)",
fl->cmd == LC_IDFVMLIB ? "LC_IDFVMLIB" :
"LC_LOADFVMLIB", i);
return(FALSE);
}
if(fl->fvmlib.name.offset >= fl->cmdsize){
error("in swap_object_headers(): truncated or malformed "
"load commands (name.offset field of %s command %lu "
"extends past the end of all load commands)",
fl->cmd == LC_IDFVMLIB ? "LC_IDFVMLIB" :
"LC_LOADFVMLIB", i);
return(FALSE);
}
break;
case LC_ID_DYLIB:
cmd_name = "LC_ID_DYLIB";
goto check_dylib_command;
case LC_LOAD_DYLIB:
cmd_name = "LC_LOAD_DYLIB";
goto check_dylib_command;
case LC_LOAD_WEAK_DYLIB:
cmd_name = "LC_LOAD_WEAK_DYLIB";
goto check_dylib_command;
case LC_REEXPORT_DYLIB:
cmd_name = "LC_REEXPORT_DYLIB";
goto check_dylib_command;
case LC_LAZY_LOAD_DYLIB:
cmd_name = "LC_LAZY_LOAD_DYLIB";
goto check_dylib_command;
check_dylib_command:
dl = (struct dylib_command *)lc;
if(dl->cmdsize < sizeof(struct dylib_command)){
error("in swap_object_headers(): malformed load commands "
"(%s command %lu has too small cmdsize field)",
cmd_name, i);
return(FALSE);
}
if(dl->dylib.name.offset >= dl->cmdsize){
error("in swap_object_headers(): truncated or malformed "
"load commands (name.offset field of %s command %lu "
"extends past the end of all load commands)",
cmd_name, i);
return(FALSE);
}
break;
case LC_SUB_FRAMEWORK:
sub = (struct sub_framework_command *)lc;
if(sub->cmdsize < sizeof(struct sub_framework_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_SUB_FRAMEWORK command %lu has too small cmdsize "
"field)", i);
return(FALSE);
}
if(sub->umbrella.offset >= sub->cmdsize){
error("in swap_object_headers(): truncated or malformed "
"load commands (umbrella.offset field of "
"LC_SUB_FRAMEWORK command %lu extends past the end "
"of all load commands)", i);
return(FALSE);
}
break;
case LC_SUB_UMBRELLA:
usub = (struct sub_umbrella_command *)lc;
if(usub->cmdsize < sizeof(struct sub_umbrella_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_SUB_UMBRELLA command %lu has too small cmdsize "
"field)", i);
return(FALSE);
}
if(usub->sub_umbrella.offset >= usub->cmdsize){
error("in swap_object_headers(): truncated or malformed "
"load commands (sub_umbrella.offset field of "
"LC_SUB_UMBRELLA command %lu extends past the end "
"of all load commands)", i);
return(FALSE);
}
break;
case LC_SUB_LIBRARY:
lsub = (struct sub_library_command *)lc;
if(lsub->cmdsize < sizeof(struct sub_library_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_SUB_LIBRARY command %lu has too small cmdsize "
"field)", i);
return(FALSE);
}
if(lsub->sub_library.offset >= lsub->cmdsize){
error("in swap_object_headers(): truncated or malformed "
"load commands (sub_library.offset field of "
"LC_SUB_LIBRARY command %lu extends past the end "
"of all load commands)", i);
return(FALSE);
}
break;
case LC_SUB_CLIENT:
csub = (struct sub_client_command *)lc;
if(csub->cmdsize < sizeof(struct sub_client_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_SUB_CLIENT command %lu has too small cmdsize "
"field)", i);
return(FALSE);
}
if(csub->client.offset >= csub->cmdsize){
error("in swap_object_headers(): truncated or malformed "
"load commands (client.offset field of "
"LC_SUB_CLIENT command %lu extends past the end "
"of all load commands)", i);
return(FALSE);
}
break;
case LC_PREBOUND_DYLIB:
pbdylib = (struct prebound_dylib_command *)lc;
if(pbdylib->cmdsize < sizeof(struct prebound_dylib_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_PREBOUND_DYLIB command %lu has too small "
"cmdsize field)", i);
return(FALSE);
}
if(pbdylib->name.offset >= pbdylib->cmdsize){
error("in swap_object_headers(): truncated or malformed "
"load commands (name.offset field of "
"LC_PREBOUND_DYLIB command %lu extends past the end "
"of all load commands)", i);
return(FALSE);
}
if(pbdylib->linked_modules.offset >= pbdylib->cmdsize){
error("in swap_object_headers(): truncated or malformed "
"load commands (linked_modules.offset field of "
"LC_PREBOUND_DYLIB command %lu extends past the end "
"of all load commands)", i);
return(FALSE);
}
break;
case LC_ID_DYLINKER:
case LC_LOAD_DYLINKER:
dyld = (struct dylinker_command *)lc;
if(dyld->cmdsize < sizeof(struct dylinker_command)){
error("in swap_object_headers(): malformed load commands "
"(%s command %lu has too small cmdsize field)",
dyld->cmd == LC_ID_DYLINKER ? "LC_ID_DYLINKER" :
"LC_LOAD_DYLINKER", i);
return(FALSE);
}
if(dyld->name.offset >= dyld->cmdsize){
error("in swap_object_headers(): truncated or malformed "
"load commands (name.offset field of %s command %lu "
"extends past the end of all load commands)",
dyld->cmd == LC_ID_DYLINKER ? "LC_ID_DYLINKER" :
"LC_LOAD_DYLINKER", i);
return(FALSE);
}
break;
case LC_UNIXTHREAD:
case LC_THREAD:
ut = (struct thread_command *)lc;
state = (char *)ut + sizeof(struct thread_command);
if(cputype == CPU_TYPE_MC680x0){
struct m68k_thread_state_regs *cpu;
struct m68k_thread_state_68882 *fpu;
struct m68k_thread_state_user_reg *user_reg;
nflavor = 0;
p = (char *)ut + ut->cmdsize;
while(state < p){
flavor = *((uint32_t *)state);
state += sizeof(uint32_t);
count = *((uint32_t *)state);
state += sizeof(uint32_t);
switch(flavor){
case M68K_THREAD_STATE_REGS:
if(count != M68K_THREAD_STATE_REGS_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not M68K_THREAD_STATE_REGS_COUNT for "
"flavor number %lu which is a M68K_THREAD_"
"STATE_REGS flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
cpu = (struct m68k_thread_state_regs *)state;
state += sizeof(struct m68k_thread_state_regs);
break;
case M68K_THREAD_STATE_68882:
if(count != M68K_THREAD_STATE_68882_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not M68K_THREAD_STATE_68882_COUNT for "
"flavor number %lu which is a M68K_THREAD_"
"STATE_68882 flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
fpu = (struct m68k_thread_state_68882 *)state;
state += sizeof(struct m68k_thread_state_68882);
break;
case M68K_THREAD_STATE_USER_REG:
if(count != M68K_THREAD_STATE_USER_REG_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not M68K_THREAD_STATE_USER_REG_COUNT for "
"flavor number %lu which is a M68K_THREAD_"
"STATE_USER_REG flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
user_reg =
(struct m68k_thread_state_user_reg *)state;
state += sizeof(struct m68k_thread_state_user_reg);
break;
default:
error("in swap_object_headers(): malformed "
"load commands (unknown "
"flavor %u for flavor number %lu in %s command"
" %lu can't byte swap it)", flavor, nflavor,
ut->cmd == LC_UNIXTHREAD ? "LC_UNIXTHREAD" :
"LC_THREAD", i);
return(FALSE);
}
nflavor++;
}
break;
}
if(cputype == CPU_TYPE_POWERPC ||
cputype == CPU_TYPE_VEO ||
cputype == CPU_TYPE_POWERPC64){
ppc_thread_state_t *cpu;
ppc_float_state_t *fpu;
ppc_exception_state_t *except;
ppc_thread_state64_t *cpu64;
nflavor = 0;
p = (char *)ut + ut->cmdsize;
while(state < p){
flavor = *((uint32_t *)state);
state += sizeof(uint32_t);
count = *((uint32_t *)state);
state += sizeof(uint32_t);
switch(flavor){
case PPC_THREAD_STATE:
if(count != PPC_THREAD_STATE_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not PPC_THREAD_STATE_COUNT for "
"flavor number %lu which is a PPC_THREAD_"
"STATE flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
cpu = (ppc_thread_state_t *)state;
state += sizeof(ppc_thread_state_t);
break;
case PPC_FLOAT_STATE:
if(count != PPC_FLOAT_STATE_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not PPC_FLOAT_STATE_COUNT for "
"flavor number %lu which is a PPC_FLOAT_"
"STATE flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
fpu = (ppc_float_state_t *)state;
state += sizeof(ppc_float_state_t);
break;
case PPC_EXCEPTION_STATE:
if(count != PPC_EXCEPTION_STATE_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not PPC_EXCEPTION_STATE_COUNT for "
"flavor number %lu which is a PPC_EXCEPT"
"ION_STATE flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
except = (ppc_exception_state_t *)state;
state += sizeof(ppc_exception_state_t);
break;
case PPC_THREAD_STATE64:
if(count != PPC_THREAD_STATE64_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not PPC_THREAD_STATE64_COUNT for "
"flavor number %lu which is a PPC_THREAD_"
"STATE64 flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
cpu64 = (ppc_thread_state64_t *)state;
state += sizeof(ppc_thread_state64_t);
break;
default:
error("in swap_object_headers(): malformed "
"load commands (unknown "
"flavor %u for flavor number %lu in %s command"
" %lu can't byte swap it)", flavor, nflavor,
ut->cmd == LC_UNIXTHREAD ? "LC_UNIXTHREAD" :
"LC_THREAD", i);
return(FALSE);
}
nflavor++;
}
break;
}
if(cputype == CPU_TYPE_MC88000){
m88k_thread_state_grf_t *cpu;
m88k_thread_state_xrf_t *fpu;
m88k_thread_state_user_t *user;
m88110_thread_state_impl_t *spu;
nflavor = 0;
p = (char *)ut + ut->cmdsize;
while(state < p){
flavor = *((uint32_t *)state);
state += sizeof(uint32_t);
count = *((uint32_t *)state);
state += sizeof(uint32_t);
switch(flavor){
case M88K_THREAD_STATE_GRF:
if(count != M88K_THREAD_STATE_GRF_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not M88K_THREAD_STATE_GRF_COUNT for "
"flavor number %lu which is a M88K_THREAD_"
"STATE_GRF flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
cpu = (m88k_thread_state_grf_t *)state;
state += sizeof(m88k_thread_state_grf_t);
break;
case M88K_THREAD_STATE_XRF:
if(count != M88K_THREAD_STATE_XRF_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not M88K_THREAD_STATE_XRF_COUNT for "
"flavor number %lu which is a M88K_THREAD_"
"STATE_XRF flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
fpu = (m88k_thread_state_xrf_t *)state;
state += sizeof(m88k_thread_state_xrf_t);
break;
case M88K_THREAD_STATE_USER:
if(count != M88K_THREAD_STATE_USER_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not M88K_THREAD_STATE_USER_COUNT for "
"flavor number %lu which is a M88K_THREAD_"
"STATE_USER flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
user = (m88k_thread_state_user_t *)state;
state += sizeof(m88k_thread_state_user_t);
break;
case M88110_THREAD_STATE_IMPL:
if(count != M88110_THREAD_STATE_IMPL_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not M88110_THREAD_STATE_IMPL_COUNT for "
"flavor number %lu which is a M88110_THREAD"
"_STATE_IMPL flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
spu = (m88110_thread_state_impl_t *)state;
state += sizeof(m88110_thread_state_impl_t);
break;
default:
error("in swap_object_headers(): malformed "
"load commands (unknown "
"flavor %u for flavor number %lu in %s command"
" %lu can't byte swap it)", flavor, nflavor,
ut->cmd == LC_UNIXTHREAD ? "LC_UNIXTHREAD" :
"LC_THREAD", i);
return(FALSE);
}
nflavor++;
}
break;
}
if(cputype == CPU_TYPE_I860){
struct i860_thread_state_regs *cpu;
nflavor = 0;
p = (char *)ut + ut->cmdsize;
while(state < p){
flavor = *((uint32_t *)state);
state += sizeof(uint32_t);
count = *((uint32_t *)state);
state += sizeof(uint32_t);
switch(flavor){
case I860_THREAD_STATE_REGS:
if(count != I860_THREAD_STATE_REGS_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not I860_THREAD_STATE_REGS_COUNT for "
"flavor number %lu which is a I860_THREAD_"
"STATE_REGS flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
cpu = (struct i860_thread_state_regs *)state;
state += sizeof(struct i860_thread_state_regs);
break;
default:
error("in swap_object_headers(): malformed "
"load commands (unknown "
"flavor %u for flavor number %lu in %s command"
" %lu can't byte swap it)", flavor, nflavor,
ut->cmd == LC_UNIXTHREAD ? "LC_UNIXTHREAD" :
"LC_THREAD", i);
return(FALSE);
}
nflavor++;
}
break;
}
if(cputype == CPU_TYPE_I386
#ifdef x86_THREAD_STATE64
|| cputype == CPU_TYPE_X86_64
#endif /* x86_THREAD_STATE64 */
){
i386_thread_state_t *cpu;
#ifdef x86_THREAD_STATE64
x86_thread_state64_t *cpu64;
#endif /* x86_THREAD_STATE64 */
/* current i386 thread states */
#if i386_THREAD_STATE == 1
struct i386_float_state *fpu;
i386_exception_state_t *exc;
#endif /* i386_THREAD_STATE == 1 */
/* i386 thread states on older releases */
#if i386_THREAD_STATE == -1
i386_thread_fpstate_t *fpu;
i386_thread_exceptstate_t *exc;
i386_thread_cthreadstate_t *user;
#endif /* i386_THREAD_STATE == -1 */
nflavor = 0;
p = (char *)ut + ut->cmdsize;
while(state < p){
flavor = *((uint32_t *)state);
state += sizeof(uint32_t);
count = *((uint32_t *)state);
state += sizeof(uint32_t);
switch(flavor){
case i386_THREAD_STATE:
/* current i386 thread states */
#if i386_THREAD_STATE == 1
case -1:
#endif /* i386_THREAD_STATE == 1 */
/* i386 thread states on older releases */
#if i386_THREAD_STATE == -1
case 1:
#endif /* i386_THREAD_STATE == -1 */
if(count != i386_THREAD_STATE_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not i386_THREAD_STATE_COUNT for flavor "
"number %lu which is a i386_THREAD_STATE "
"flavor in %s command %lu)", nflavor,
ut->cmd == LC_UNIXTHREAD ? "LC_UNIXTHREAD" :
"LC_THREAD", i);
return(FALSE);
}
cpu = (i386_thread_state_t *)state;
state += sizeof(i386_thread_state_t);
break;
/* current i386 thread states */
#if i386_THREAD_STATE == 1
case i386_FLOAT_STATE:
if(count != i386_FLOAT_STATE_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not i386_FLOAT_STATE_COUNT for flavor "
"number %lu which is a i386_FLOAT_STATE "
"flavor in %s command %lu)", nflavor,
ut->cmd == LC_UNIXTHREAD ? "LC_UNIXTHREAD" :
"LC_THREAD", i);
return(FALSE);
}
fpu = (struct i386_float_state *)state;
state += sizeof(struct i386_float_state);
break;
case i386_EXCEPTION_STATE:
if(count != I386_EXCEPTION_STATE_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not I386_EXCEPTION_STATE_COUNT for "
"flavor number %lu which is a i386_"
"EXCEPTION_STATE flavor in %s command %lu)",
nflavor,
ut->cmd == LC_UNIXTHREAD ? "LC_UNIXTHREAD" :
"LC_THREAD", i);
return(FALSE);
}
exc = (i386_exception_state_t *)state;
state += sizeof(i386_exception_state_t);
break;
#endif /* i386_THREAD_STATE == 1 */
/* i386 thread states on older releases */
#if i386_THREAD_STATE == -1
case i386_THREAD_FPSTATE:
if(count != i386_THREAD_FPSTATE_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not i386_THREAD_FPSTATE_COUNT for flavor "
"number %lu which is a i386_THREAD_FPSTATE "
"flavor in %s command %lu)", nflavor,
ut->cmd == LC_UNIXTHREAD ? "LC_UNIXTHREAD" :
"LC_THREAD", i);
return(FALSE);
}
fpu = (i386_thread_fpstate_t *)state;
state += sizeof(i386_thread_fpstate_t);
break;
case i386_THREAD_EXCEPTSTATE:
if(count != i386_THREAD_EXCEPTSTATE_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not i386_THREAD_EXCEPTSTATE_COUNT for "
"flavor number %lu which is a i386_THREAD_"
"EXCEPTSTATE flavor in %s command %lu)",
nflavor,
ut->cmd == LC_UNIXTHREAD ? "LC_UNIXTHREAD" :
"LC_THREAD", i);
return(FALSE);
}
exc = (i386_thread_exceptstate_t *)state;
state += sizeof(i386_thread_fpstate_t);
break;
case i386_THREAD_CTHREADSTATE:
if(count != i386_THREAD_CTHREADSTATE_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not i386_THREAD_CTHREADSTATE_COUNT for "
"flavor number %lu which is a i386_THREAD_"
"CTHREADSTATE flavor in %s command %lu)",
nflavor,
ut->cmd == LC_UNIXTHREAD ? "LC_UNIXTHREAD" :
"LC_THREAD", i);
return(FALSE);
}
user = (i386_thread_cthreadstate_t *)state;
state += sizeof(i386_thread_fpstate_t);
break;
#endif /* i386_THREAD_STATE == -1 */
#ifdef x86_THREAD_STATE64
case x86_THREAD_STATE64:
if(count != x86_THREAD_STATE64_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not x86_THREAD_STATE64_COUNT for "
"flavor number %lu which is an x86_THREAD_"
"STATE64 flavor in %s command %lu)",
nflavor,
ut->cmd == LC_UNIXTHREAD ? "LC_UNIXTHREAD" :
"LC_THREAD", i);
return(FALSE);
}
cpu64 = (x86_thread_state64_t *)state;
state += sizeof(x86_thread_state64_t);
break;
#endif /* x86_THREAD_STATE64 */
default:
error("in swap_object_headers(): malformed "
"load commands (unknown "
"flavor %u for flavor number %lu in %s command"
" %lu can't byte swap it)", flavor, nflavor,
ut->cmd == LC_UNIXTHREAD ? "LC_UNIXTHREAD" :
"LC_THREAD", i);
return(FALSE);
}
nflavor++;
}
break;
}
if(cputype == CPU_TYPE_HPPA){
struct hp_pa_integer_thread_state *cpu;
struct hp_pa_frame_thread_state *frame;
struct hp_pa_fp_thread_state *fpu;
nflavor = 0;
p = (char *)ut + ut->cmdsize;
while(state < p){
flavor = *((uint32_t *)state);
state += sizeof(uint32_t);
count = *((uint32_t *)state);
state += sizeof(uint32_t);
switch(flavor){
case HPPA_INTEGER_THREAD_STATE:
if(count != HPPA_INTEGER_THREAD_STATE_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not HPPA_INTEGER_THREAD_STATE_COUNT for "
"flavor number %lu which is a HPPA_INTEGER"
"_THREAD_STATE flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
cpu = (struct hp_pa_integer_thread_state *)state;
state += sizeof(struct hp_pa_integer_thread_state);
break;
case HPPA_FRAME_THREAD_STATE:
if(count != HPPA_FRAME_THREAD_STATE_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not HPPA_FRAME_THREAD_STATE_COUNT for "
"flavor number %lu which is a HPPA_FRAME"
"_THREAD_STATE flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
frame = (struct hp_pa_frame_thread_state *)state;
state += sizeof(struct hp_pa_frame_thread_state);
break;
case HPPA_FP_THREAD_STATE:
if(count != HPPA_FP_THREAD_STATE_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not HPPA_FP_THREAD_STATE_COUNT for "
"flavor number %lu which is a HPPA_FP"
"_THREAD_STATE flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
fpu = (struct hp_pa_fp_thread_state *)state;
state += sizeof(struct hp_pa_fp_thread_state);
break;
default:
error("in swap_object_headers(): malformed "
"load commands (unknown "
"flavor %u for flavor number %lu in %s command"
" %lu can't byte swap it)", flavor, nflavor,
ut->cmd == LC_UNIXTHREAD ? "LC_UNIXTHREAD" :
"LC_THREAD", i);
return(FALSE);
}
nflavor++;
}
break;
}
if(cputype == CPU_TYPE_SPARC) {
struct sparc_thread_state_regs *cpu;
struct sparc_thread_state_fpu *fpu;
nflavor = 0;
p = (char *)ut + ut->cmdsize;
while (state < p) {
flavor = *((uint32_t *) state);
state += sizeof(uint32_t);
count = *((uint32_t *) state);
state += sizeof(uint32_t);
switch (flavor) {
case SPARC_THREAD_STATE_REGS:
if (count != SPARC_THREAD_STATE_REGS_COUNT) {
error("in swap_object_headers(): malformed "
"load commands (count "
"not SPARC_THREAD_STATE_REGS_COUNT for "
"flavor number %lu which is a SPARC_THREAD_"
"STATE_REGS flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
cpu = (struct sparc_thread_state_regs *) state;
state += sizeof(struct sparc_thread_state_regs);
break;
case SPARC_THREAD_STATE_FPU:
if (count != SPARC_THREAD_STATE_FPU_COUNT) {
error("in swap_object_headers(): malformed "
"load commands (count "
"not SPARC_THREAD_STATE_FPU_COUNT for "
"flavor number %lu which is a SPARC_THREAD_"
"STATE_FPU flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
fpu = (struct sparc_thread_state_fpu *) state;
state += sizeof(struct sparc_thread_state_fpu);
break;
}
}
break;
}
if(cputype == CPU_TYPE_ARM){
arm_thread_state_t *cpu;
nflavor = 0;
p = (char *)ut + ut->cmdsize;
while(state < p){
flavor = *((uint32_t *)state);
state += sizeof(uint32_t);
count = *((uint32_t *)state);
state += sizeof(uint32_t);
switch(flavor){
case ARM_THREAD_STATE:
if(count != ARM_THREAD_STATE_COUNT){
error("in swap_object_headers(): malformed "
"load commands (count "
"not ARM_THREAD_STATE_COUNT for "
"flavor number %lu which is a ARM_THREAD_"
"STATE flavor in %s command %lu)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
cpu = (arm_thread_state_t *)state;
state += sizeof(arm_thread_state_t);
break;
default:
error("in swap_object_headers(): malformed load "
"commands (unknown flavor for flavor number "
"%lu in %s command %lu can't byte swap it)",
nflavor, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
}
nflavor++;
}
break;
}
error("in swap_object_headers(): malformed load commands "
"(unknown cputype (%d) and cpusubtype (%d) of object and "
"can't byte swap %s command %lu)", cputype,
cpusubtype, ut->cmd == LC_UNIXTHREAD ?
"LC_UNIXTHREAD" : "LC_THREAD", i);
return(FALSE);
case LC_IDENT:
id = (struct ident_command *)lc;
if((char *)id + id->cmdsize >
(char *)load_commands + sizeofcmds){
error("in swap_object_headers(): truncated or malformed "
"load commands (cmdsize field of LC_IDENT command %lu "
"extends past the end of the load commands)", i);
return(FALSE);
}
break;
case LC_ROUTINES:
rc = (struct routines_command *)lc;
if(rc->cmdsize != sizeof(struct routines_command)){
error("in swap_object_headers(): malformed load commands ("
"LC_ROUTINES command %lu has incorrect cmdsize",
i);
return(FALSE);
}
break;
case LC_ROUTINES_64:
rc64 = (struct routines_command_64 *)lc;
if(rc64->cmdsize != sizeof(struct routines_command_64)){
error("in swap_object_headers(): malformed load commands ("
"LC_ROUTINES_64 command %lu has incorrect cmdsize",
i);
return(FALSE);
}
break;
case LC_TWOLEVEL_HINTS:
hints = (struct twolevel_hints_command *)lc;
if(hints->cmdsize != sizeof(struct twolevel_hints_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_TWOLEVEL_HINTS command %lu has incorrect "
"cmdsize", i);
return(FALSE);
}
break;
case LC_PREBIND_CKSUM:
cs = (struct prebind_cksum_command *)lc;
if(cs->cmdsize != sizeof(struct prebind_cksum_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_PREBIND_CKSUM command %lu has incorrect cmdsize",
i);
return(FALSE);
}
break;
case LC_UUID:
uuid = (struct uuid_command *)lc;
if(uuid->cmdsize != sizeof(struct uuid_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_UUID command %lu has incorrect cmdsize", i);
return(FALSE);
}
break;
case LC_CODE_SIGNATURE:
ld = (struct linkedit_data_command *)lc;
if(ld->cmdsize != sizeof(struct linkedit_data_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_CODE_SIGNATURE command %lu has incorrect "
"cmdsize", i);
return(FALSE);
}
break;
case LC_SEGMENT_SPLIT_INFO:
ld = (struct linkedit_data_command *)lc;
if(ld->cmdsize != sizeof(struct linkedit_data_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_SEGMENT_SPLIT_INFO command %lu has incorrect "
"cmdsize", i);
return(FALSE);
}
break;
case LC_RPATH:
rpath = (struct rpath_command *)lc;
if(rpath->cmdsize < sizeof(struct rpath_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_RPATH command %lu has too small cmdsize field)",
i);
return(FALSE);
}
if(rpath->path.offset >= rpath->cmdsize){
error("in swap_object_headers(): truncated or malformed "
"load commands (path.offset field of LC_RPATH "
"command %lu extends past the end of all load "
"commands)", i);
return(FALSE);
}
break;
case LC_ENCRYPTION_INFO:
ec = (struct encryption_info_command *)lc;
if(ec->cmdsize != sizeof(struct encryption_info_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_ENCRYPTION_INFO command %lu has incorrect "
"cmdsize", i);
return(FALSE);
}
break;
case LC_DYLD_INFO:
case LC_DYLD_INFO_ONLY:
dc = (struct dyld_info_command *)lc;
if(dc->cmdsize != sizeof(struct dyld_info_command)){
error("in swap_object_headers(): malformed load commands "
"(LC_DYLD_INFO command %lu has incorrect "
"cmdsize", i);
return(FALSE);
}
break;
default:
error("in swap_object_headers(): malformed load commands "
"(unknown load command %lu)", i);
return(FALSE);
}
lc = (struct load_command *)((char *)lc + l.cmdsize);
/* check that next load command does not extends past the end */
if((char *)lc > (char *)load_commands + sizeofcmds){
error("in swap_object_headers(): truncated or malformed load "
"commands (load command %lu extends past the end of all "
"load commands)", i + 1);
return(FALSE);
}
}
/* check for an inconsistent size of the load commands */
if((char *)load_commands + sizeofcmds != (char *)lc){
error("in swap_object_headers(): malformed load commands "
"(inconsistent sizeofcmds field in mach header)");
return(FALSE);
}
/*
* Now knowing the load commands can be parsed swap them.
*/
target_byte_sex = get_host_byte_sex() == BIG_ENDIAN_BYTE_SEX ?
LITTLE_ENDIAN_BYTE_SEX : BIG_ENDIAN_BYTE_SEX;
for(i = 0, lc = load_commands; i < ncmds; i++){
l = *lc;
switch(lc->cmd){
case LC_SEGMENT:
sg = (struct segment_command *)lc;
s = (struct section *)
((char *)sg + sizeof(struct segment_command));
swap_section(s, sg->nsects, target_byte_sex);
swap_segment_command(sg, target_byte_sex);
break;
case LC_SEGMENT_64:
sg64 = (struct segment_command_64 *)lc;
s64 = (struct section_64 *)
((char *)sg64 + sizeof(struct segment_command_64));
swap_section_64(s64, sg64->nsects, target_byte_sex);
swap_segment_command_64(sg64, target_byte_sex);
break;
case LC_SYMTAB:
st = (struct symtab_command *)lc;
swap_symtab_command(st, target_byte_sex);
break;
case LC_DYSYMTAB:
dyst = (struct dysymtab_command *)lc;
swap_dysymtab_command(dyst, target_byte_sex);
break;
case LC_SYMSEG:
ss = (struct symseg_command *)lc;
swap_symseg_command(ss, target_byte_sex);
break;
case LC_IDFVMLIB:
case LC_LOADFVMLIB:
fl = (struct fvmlib_command *)lc;
swap_fvmlib_command(fl, target_byte_sex);
break;
case LC_ID_DYLIB:
case LC_LOAD_DYLIB:
case LC_LOAD_WEAK_DYLIB:
case LC_REEXPORT_DYLIB:
case LC_LAZY_LOAD_DYLIB:
dl = (struct dylib_command *)lc;
swap_dylib_command(dl, target_byte_sex);
break;
case LC_SUB_FRAMEWORK:
sub = (struct sub_framework_command *)lc;
swap_sub_framework_command(sub, target_byte_sex);
break;
case LC_SUB_UMBRELLA:
usub = (struct sub_umbrella_command *)lc;
swap_sub_umbrella_command(usub, target_byte_sex);
break;
case LC_SUB_LIBRARY:
lsub = (struct sub_library_command *)lc;
swap_sub_library_command(lsub, target_byte_sex);
break;
case LC_SUB_CLIENT:
csub = (struct sub_client_command *)lc;
swap_sub_client_command(csub, target_byte_sex);
break;
case LC_PREBOUND_DYLIB:
pbdylib = (struct prebound_dylib_command *)lc;
swap_prebound_dylib_command(pbdylib, target_byte_sex);
break;
case LC_ID_DYLINKER:
case LC_LOAD_DYLINKER:
dyld = (struct dylinker_command *)lc;
swap_dylinker_command(dyld, target_byte_sex);
break;
case LC_UNIXTHREAD:
case LC_THREAD:
ut = (struct thread_command *)lc;
state = (char *)ut + sizeof(struct thread_command);
p = (char *)ut + ut->cmdsize;
swap_thread_command(ut, target_byte_sex);
if(cputype == CPU_TYPE_MC680x0){
struct m68k_thread_state_regs *cpu;
struct m68k_thread_state_68882 *fpu;
struct m68k_thread_state_user_reg *user_reg;
while(state < p){
flavor = *((uint32_t *)state);
*((uint32_t *)state) = SWAP_INT(flavor);
state += sizeof(uint32_t);
count = *((uint32_t *)state);
*((uint32_t *)state) = SWAP_INT(count);
state += sizeof(uint32_t);
switch(flavor){
case M68K_THREAD_STATE_REGS:
cpu = (struct m68k_thread_state_regs *)state;
swap_m68k_thread_state_regs(cpu, target_byte_sex);
state += sizeof(struct m68k_thread_state_regs);
break;
case M68K_THREAD_STATE_68882:
fpu = (struct m68k_thread_state_68882 *)state;
swap_m68k_thread_state_68882(fpu, target_byte_sex);
state += sizeof(struct m68k_thread_state_68882);
break;
case M68K_THREAD_STATE_USER_REG:
user_reg =
(struct m68k_thread_state_user_reg *)state;
swap_m68k_thread_state_user_reg(user_reg,
target_byte_sex);
state += sizeof(struct m68k_thread_state_user_reg);
break;
}
}
break;
}
if(cputype == CPU_TYPE_POWERPC ||
cputype == CPU_TYPE_VEO ||
cputype == CPU_TYPE_POWERPC64){
ppc_thread_state_t *cpu;
ppc_thread_state64_t *cpu64;
ppc_float_state_t *fpu;
ppc_exception_state_t *except;
while(state < p){
flavor = *((uint32_t *)state);
*((uint32_t *)state) = SWAP_INT(flavor);
state += sizeof(uint32_t);
count = *((uint32_t *)state);
*((uint32_t *)state) = SWAP_INT(count);
state += sizeof(uint32_t);
switch(flavor){
case PPC_THREAD_STATE:
cpu = (ppc_thread_state_t *)state;
swap_ppc_thread_state_t(cpu, target_byte_sex);
state += sizeof(ppc_thread_state_t);
break;
case PPC_THREAD_STATE64:
cpu64 = (ppc_thread_state64_t *)state;
swap_ppc_thread_state64_t(cpu64, target_byte_sex);
state += sizeof(ppc_thread_state64_t);
break;
case PPC_FLOAT_STATE:
fpu = (ppc_float_state_t *)state;
swap_ppc_float_state_t(fpu, target_byte_sex);
state += sizeof(ppc_float_state_t);
case PPC_EXCEPTION_STATE:
except = (ppc_exception_state_t *)state;
swap_ppc_exception_state_t(except, target_byte_sex);
state += sizeof(ppc_exception_state_t);
break;
}
}
break;
}
if(cputype == CPU_TYPE_MC88000){
m88k_thread_state_grf_t *cpu;
m88k_thread_state_xrf_t *fpu;
m88k_thread_state_user_t *user;
m88110_thread_state_impl_t *spu;
while(state < p){
flavor = *((uint32_t *)state);
*((uint32_t *)state) = SWAP_INT(flavor);
state += sizeof(uint32_t);
count = *((uint32_t *)state);
*((uint32_t *)state) = SWAP_INT(count);
state += sizeof(uint32_t);
switch(flavor){
case M88K_THREAD_STATE_GRF:
cpu = (m88k_thread_state_grf_t *)state;
swap_m88k_thread_state_grf_t(cpu,
target_byte_sex);
state += sizeof(m88k_thread_state_grf_t);
break;
case M88K_THREAD_STATE_XRF:
fpu = (m88k_thread_state_xrf_t *)state;
swap_m88k_thread_state_xrf_t(fpu,
target_byte_sex);
state += sizeof(m88k_thread_state_xrf_t);
break;
case M88K_THREAD_STATE_USER:
user = (m88k_thread_state_user_t *)state;
swap_m88k_thread_state_user_t(user,
target_byte_sex);
state += sizeof(m88k_thread_state_user_t);
break;
case M88110_THREAD_STATE_IMPL:
spu = (m88110_thread_state_impl_t *)state;
swap_m88110_thread_state_impl_t(spu,
target_byte_sex);
state += sizeof(m88110_thread_state_impl_t);
break;
}
}
break;
}
if(cputype == CPU_TYPE_I860){
struct i860_thread_state_regs *cpu;
while(state < p){
flavor = *((uint32_t *)state);
*((uint32_t *)state) = SWAP_INT(flavor);
state += sizeof(uint32_t);
count = *((uint32_t *)state);
*((uint32_t *)state) = SWAP_INT(count);
state += sizeof(uint32_t);
switch(flavor){
case I860_THREAD_STATE_REGS:
cpu = (struct i860_thread_state_regs *)state;
swap_i860_thread_state_regs(cpu, target_byte_sex);
state += sizeof(struct i860_thread_state_regs);
break;
}
}
break;
}
if(cputype == CPU_TYPE_I386
#ifdef x86_THREAD_STATE64
|| cputype == CPU_TYPE_X86_64
#endif /* x86_THREAD_STATE64 */
){
i386_thread_state_t *cpu;
#ifdef x86_THREAD_STATE64
x86_thread_state64_t *cpu64;
#endif /* x86_THREAD_STATE64 */
/* current i386 thread states */
#if i386_THREAD_STATE == 1
struct i386_float_state *fpu;
i386_exception_state_t *exc;
#endif /* i386_THREAD_STATE == 1 */
/* i386 thread states on older releases */
#if i386_THREAD_STATE == -1
i386_thread_fpstate_t *fpu;
i386_thread_exceptstate_t *exc;
i386_thread_cthreadstate_t *user;
#endif /* i386_THREAD_STATE == -1 */
while(state < p){
flavor = *((uint32_t *)state);
*((uint32_t *)state) = SWAP_INT(flavor);
state += sizeof(uint32_t);
count = *((uint32_t *)state);
*((uint32_t *)state) = SWAP_INT(count);
state += sizeof(uint32_t);
switch(flavor){
case i386_THREAD_STATE:
/* current i386 thread states */
#if i386_THREAD_STATE == 1
case -1:
#endif /* i386_THREAD_STATE == 1 */
/* i386 thread states on older releases */
#if i386_THREAD_STATE == -1
case 1:
#endif /* i386_THREAD_STATE == -1 */
cpu = (i386_thread_state_t *)state;
swap_i386_thread_state(cpu, target_byte_sex);
state += sizeof(i386_thread_state_t);
break;
/* current i386 thread states */
#if i386_THREAD_STATE == 1
case i386_FLOAT_STATE:
fpu = (struct i386_float_state *)state;
swap_i386_float_state(fpu, target_byte_sex);
state += sizeof(struct i386_float_state);
break;
case i386_EXCEPTION_STATE:
exc = (i386_exception_state_t *)state;
swap_i386_exception_state(exc, target_byte_sex);
state += sizeof(i386_exception_state_t);
break;
#endif /* i386_THREAD_STATE == 1 */
/* i386 thread states on older releases */
#if i386_THREAD_STATE == -1
case i386_THREAD_FPSTATE:
fpu = (i386_thread_fpstate_t *)state;
swap_i386_thread_fpstate(fpu, target_byte_sex);
state += sizeof(i386_thread_fpstate_t);
break;
case i386_THREAD_EXCEPTSTATE:
exc = (i386_thread_exceptstate_t *)state;
swap_i386_thread_exceptstate(exc, target_byte_sex);
state += sizeof(i386_thread_exceptstate_t);
break;
case i386_THREAD_CTHREADSTATE:
user = (i386_thread_cthreadstate_t *)state;
swap_i386_thread_cthreadstate(user,target_byte_sex);
state += sizeof(i386_thread_cthreadstate_t);
break;
#endif /* i386_THREAD_STATE == -1 */
#ifdef x86_THREAD_STATE64
case x86_THREAD_STATE64:
cpu64 = (x86_thread_state64_t *)state;
swap_x86_thread_state64(cpu64, target_byte_sex);
state += sizeof(x86_thread_state64_t);
break;
#endif /* x86_THREAD_STATE64 */
}
}
break;
}
if(cputype == CPU_TYPE_HPPA){
struct hp_pa_integer_thread_state *cpu;
struct hp_pa_frame_thread_state *frame;
struct hp_pa_fp_thread_state *fpu;
while(state < p){
flavor = *((uint32_t *)state);
*((uint32_t *)state) = SWAP_INT(flavor);
state += sizeof(uint32_t);
count = *((uint32_t *)state);
*((uint32_t *)state) = SWAP_INT(count);
state += sizeof(uint32_t);
switch(flavor){
case HPPA_INTEGER_THREAD_STATE:
cpu = (struct hp_pa_integer_thread_state *)state;
swap_hppa_integer_thread_state(cpu,
target_byte_sex);
state += sizeof(struct hp_pa_integer_thread_state);
break;
case HPPA_FRAME_THREAD_STATE:
frame = (struct hp_pa_frame_thread_state *)state;
swap_hppa_frame_thread_state(frame,
target_byte_sex);
state += sizeof(struct hp_pa_frame_thread_state);
break;
case HPPA_FP_THREAD_STATE:
fpu = (struct hp_pa_fp_thread_state *)state;
swap_hppa_fp_thread_state(fpu,
target_byte_sex);
state += sizeof(struct hp_pa_fp_thread_state);
break;
}
}
break;
}
if(cputype == CPU_TYPE_SPARC) {
struct sparc_thread_state_regs *cpu;
struct sparc_thread_state_fpu *fpu;
while (state < p) {
flavor = *((uint32_t *) state);
*((uint32_t *) state) = SWAP_INT(flavor);
state += sizeof(uint32_t);
count = *((unsigned int *) state);
*((unsigned int *) state) = SWAP_INT(count);
state += sizeof(uint32_t);
switch (flavor) {
case SPARC_THREAD_STATE_REGS:
cpu = (struct sparc_thread_state_regs *) state;
swap_sparc_thread_state_regs(cpu, target_byte_sex);
state += sizeof(struct sparc_thread_state_regs);
break;
case SPARC_THREAD_STATE_FPU:
fpu = (struct sparc_thread_state_fpu *) state;
swap_sparc_thread_state_fpu(fpu, target_byte_sex);
state += sizeof(struct sparc_thread_state_fpu);
break;
}
}
break;
}
if(cputype == CPU_TYPE_ARM){
arm_thread_state_t *cpu;
while(state < p){
flavor = *((uint32_t *)state);
*((uint32_t *)state) = SWAP_INT(flavor);
state += sizeof(uint32_t);
count = *((uint32_t *)state);
*((uint32_t *)state) = SWAP_INT(count);
state += sizeof(uint32_t);
switch(flavor){
case ARM_THREAD_STATE:
cpu = (arm_thread_state_t *)state;
swap_arm_thread_state_t(cpu, target_byte_sex);
state += sizeof(arm_thread_state_t);
break;
}
}
break;
}
break;
case LC_IDENT:
id = (struct ident_command *)lc;
swap_ident_command(id, target_byte_sex);
break;
case LC_ROUTINES:
rc = (struct routines_command *)lc;
swap_routines_command(rc, target_byte_sex);
break;
case LC_ROUTINES_64:
rc64 = (struct routines_command_64 *)lc;
swap_routines_command_64(rc64, target_byte_sex);
break;
case LC_TWOLEVEL_HINTS:
hints = (struct twolevel_hints_command *)lc;
swap_twolevel_hints_command(hints, target_byte_sex);
break;
case LC_PREBIND_CKSUM:
cs = (struct prebind_cksum_command *)lc;
swap_prebind_cksum_command(cs, target_byte_sex);
break;
case LC_UUID:
uuid = (struct uuid_command *)lc;
swap_uuid_command(uuid, target_byte_sex);
break;
case LC_CODE_SIGNATURE:
case LC_SEGMENT_SPLIT_INFO:
ld = (struct linkedit_data_command *)lc;
swap_linkedit_data_command(ld, target_byte_sex);
break;
case LC_RPATH:
rpath = (struct rpath_command *)lc;
swap_rpath_command(rpath, target_byte_sex);
break;
case LC_ENCRYPTION_INFO:
ec = (struct encryption_info_command *)lc;
swap_encryption_command(ec, target_byte_sex);
break;
case LC_DYLD_INFO:
case LC_DYLD_INFO_ONLY:
dc = (struct dyld_info_command *)lc;
swap_dyld_info_command(dc, target_byte_sex);
break;
}
lc = (struct load_command *)((char *)lc + l.cmdsize);
}
if(mh != NULL)
swap_mach_header(mh, target_byte_sex);
else
swap_mach_header_64(mh64, target_byte_sex);
return(TRUE);
}
