ld.c

/*
   http://em386.blogspot.com

   You may not use this code in a product,
    but feel free to study it and rewrite it
   in your own way

   This code is an example of how to use the
   libelf library for reading ELF objects.

   gcc -o libelf-howto libelf-howto.c -lelf
*/

//#include <stdio.h>
//#include <string.h>
//#include <stdlib.h>
//#include <unistd.h>
#include "fcntl.h"

#include <libelf/libelf.h>
#include <libelf/gelf.h>
#include "ld.h"
#include"types.h"
#include"stat.h"
#include"user.h"

#define TEXT_INDEX 1
#define DATA_INDEX 2
#define BSS_INDEX 3
#define ERR -1
#define ALIGN(x) 32 - (x % 32) + x

char prasann[512];
char buf[512];
int argtextsize[3];
int argdatasize[3];
char header_buf[] = {
 0x7f,0x45, 0x4c,0x46, 0x01,0x01, 0x01,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00,
 0x02,0x00, 0x03,0x00, 0x01,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00, 0x34,0x00, 0x00,0x00,
 0xd4,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00, 0x34,0x00, 0x20,0x00, 0x01,0x00, 0x28,0x00,
 0x07,0x00, 0x04,0x00, 0x01,0x00, 0x00,0x00, 0x60,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00,
 0x00,0x00, 0x00,0x00, 0x48,0x00, 0x00,0x00, 0x68,0x00, 0x00,0x00, 0x07,0x00, 0x00,0x00,
 0x20,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00
};

int definition_not_found(Node *undefined_object_file){
        Node *p;
        p = undefined_object_file;
        printf("............................\n");
        traverse(undefined_object_file);
        p = p->next;
        while(p != NULL){
                if(p->argindex >= 0){
                        printf("%s: missing definition\n",p->name);
                        return 1;
                }
                p = p->next;
        }
        return 0;
}
void get_undefined_entries(Elf *elf,Node **undefined_object_file1,Node **defined_object_file1,int argindex){

        /* segregate symbol table entries into defined and undefined 
           argument : Elf *elf, from which symbol are to be separated out
           requirements: Global pointers from undefined symbols and defined symbols of type GElf_Sym ** should be declared 
           return values: It returns none, but will malloc above mentioned arrays */
        int i,j,k,symbol_count;
        Elf_Scn *scn1 = NULL;
        GElf_Shdr shdr;
        Elf_Data *edata = NULL;
        GElf_Sym *sym  ;
        i = j = k = 0;
        printf("before loop\n");
        while((scn1 = elf_nextscn(elf, scn1)) != NULL)
        {
                printf("in loop\n");
                gelf_getshdr(scn1, &shdr);

                // When we find a section header marked SHT_SYMTAB stop and get symbols
                if(shdr.sh_type == SHT_SYMTAB)
                {
                        // edata points to our symbol table
                        edata = elf_getdata(scn1, edata);
                        symbol_count = (int ) shdr.sh_size / (int ) shdr.sh_entsize;
                        int counter = (int)sizeof(Elf32_Rel);

                        /*      how many symbols are there?
                                his number comes from the size of // the section divided by the entry size
                                libelf grabs the symbol data using gelf_getsym()
                         */

                        for(i = 0 ; i < symbol_count ; i++){

                                sym = (GElf_Sym *)malloc(sizeof(GElf_Sym));
                                gelf_getsym(edata, i, sym);

                                if(sym->st_shndx  == SHN_UNDEF){
//                                      if(ELF32_ST_BIND(sym->st_info) == 1)//this checks for local declaration
                                                insert(undefined_object_file1,sym,elf_strptr(elf,shdr.sh_link,sym->st_name),argindex);
                                }else{
                                        if(ELF32_ST_TYPE(sym->st_info) != STT_FILE)
                                                insert(defined_object_file1,sym,elf_strptr(elf,shdr.sh_link,sym->st_name),argindex);
                                }
                        }
                }
        }
}
char *get_section_content(Elf *elf,int *size,int index){
        printf("In function get section content\n");
        Elf_Scn *scn;
        Elf_Data *edata = NULL;
        Elf32_Shdr *shdr;
        char *data;
        int i = 0;

        if(!(scn = elf_getscn(elf,index))){
                printf("error getting text section\n");
                return NULL;
        }
        if(!(shdr = elf32_getshdr(scn))){
                printf("error getting text section header\n");
                return NULL;
        }

        if(!(edata = elf_getdata(scn,edata))){
                printf("error getting text data\n");
                return NULL;
        }
        data = (char *)malloc(sizeof(char) * (int)edata->d_size);

        for( i = 0 ; i < (int)edata->d_size ; i++){
                *(data + i) = (char)*((char *)edata->d_buf + i);
                printf(" %x ", *(data + i));
        }
        printf("\n\n");
        *size = i;
        return data;
}
int resolve_undefined_reference(Node **undefined1, Node **defined1,Node **defined2 , Node **undefined2){
        
        Node *u = *undefined1;
        Node *tmp;
        GElf_Sym *sym;
        while(u){
                if(tmp = (Node *)ispresent(*defined2,u->name)){
                        if( !(ispresent(*undefined2,u->name))){
                                sym = (GElf_Sym *)malloc(sizeof(GElf_Sym));
                                memcpy(sym,tmp->symbol,sizeof(GElf_Sym));
                                insert(defined1,sym,tmp->name,tmp->argindex);
                                u->argindex = -1;

                        }
                }
                u = u->next;
        }
}
int update(Node **undefined1,Node **defined1){
        Node *u = *undefined1;
        Node *p = *defined1;
        /*
        printf("before update function defined\n");
        traverse(*defined1);
        printf("before update function undefined\n");
        traverse(*undefined1);
        */
        int text = 0;
        int data = 0;
        int bss = 0;
        int i;
//      while(u){
                p = *defined1;
                while(p){

//                      if(!strcmp(u->name,p->name)){

                                text = data = 0;
                                for(i = 0 ; i < p->argindex;i++)
                                        text += ALIGN(argtextsize[i]); 
                                for(i = 0 ; i < p->argindex;i++)
                                        data += ALIGN(argdatasize[i]); 
                //              printf("symbol %s t:%d d:%d\n",p->name, text,data);

                                if(p->symbol->st_shndx == 1)
                                        p->symbol->st_value += text;
                                else if(p->symbol->st_shndx == 2)
                                        p->symbol->st_value += data;
                                else if(p->symbol->st_shndx == 3)
                                        p->symbol->st_value += bss;

                                p = p->next;
//                              break;
                        }
//                      p = p->next;
//              }
//              u = u->next;
//      }
}
char *get_symbol_name(Elf *elf,int index){
        
        Elf_Scn *scn = NULL;
        Elf_Data *edata = NULL;
        GElf_Shdr shdr;                 /* Section Header */
        char *data;
        GElf_Sym sym;
        while((scn = elf_nextscn(elf, scn)) != NULL)
        {
                gelf_getshdr(scn, &shdr);
                // When we find a section header marked SHT_SYMTAB stop and get symbols
                if(shdr.sh_type == SHT_SYMTAB)
                {
                        // edata points to our symbol table
                        edata = elf_getdata(scn, edata);
                        // libelf grabs the symbol data using gelf_getsym()
                        gelf_getsym(edata,index, &sym);
                        // print out the value and size
                        return elf_strptr(elf, shdr.sh_link, sym.st_name);
                }
        }

}
void do_relocation(Elf *elf,Node *defined1,char *text,char * data,int textsize, int start_text ,  int start_data){      
        int symbol_count;
        int i;
        Elf_Scn *scn1 = NULL;
        GElf_Shdr shdr;
        Elf_Data *edata = NULL;
        GElf_Rel *rel,rel_mem;
        char *sym_name;
        Node *symbol_entry = NULL;
        char *refptr = NULL;
        int tmp;

        while((scn1 = elf_nextscn(elf, scn1)) != NULL)
        {
                gelf_getshdr(scn1, &shdr);

                if(shdr.sh_type == SHT_REL){
                        // edata points to our symbol table
                        edata = elf_getdata(scn1, edata);
                        symbol_count = (int)shdr.sh_size / (int)shdr.sh_entsize;
                        int counter = (int)sizeof(Elf32_Rel);
                        for(i = 0 ; i < symbol_count ; i++){
                                /*get every entry from relocation table*/
                                rel = gelf_getrel(edata,i,&rel_mem);
                                
                                /*get it's newly modified address from defined1 symlist*/
                                sym_name = get_symbol_name(elf,(int)GELF_R_SYM(rel->r_info));
                                symbol_entry = (Node *)ispresent(defined1,sym_name);
                                printf("symbol is %s and symbol value %d",sym_name ,(int) symbol_entry->symbol->st_value);
                                if(symbol_entry == NULL){
                                        printf("\nUndefined reference to symbol %s\n",sym_name);
                                        return ;
                                }
                                        
                                /*check relocation table entries type from relocation table*/
                                if(ELF32_ST_TYPE(rel->r_info) == R_386_PC32){
                                       /*if it is a function*/
                                                refptr = text + (int)rel->r_offset + start_text;
                                        if(symbol_entry->symbol->st_shndx == 1){
                                                /* it from text section */
                                                
                                                tmp  = (int)(( symbol_entry->symbol->st_value) - (int)rel->r_offset - start_text + *(int*)refptr );
                                                //printf("value in text pc32  tmp = %d and rel offset = %d\n",(int)tmp,(int)rel->r_offset);
                                                *(int *)refptr =  tmp;
                                        }else if(symbol_entry->symbol->st_shndx == 2){
                                                tmp = (int)(  textsize - symbol_entry->symbol->st_value -(int)rel->r_offset +*(int*)refptr);
                                                *(int *)refptr =  tmp;
                                        }
                                }else if(ELF32_ST_TYPE(rel->r_info) == R_386_32){
                                        /*if it is a variable*/
                                        refptr = text + (int)rel->r_offset + start_text;
                                        if(symbol_entry->symbol->st_shndx == 1){
                                                /* it from text section */
                                        //      refptr = text + (int)rel->r_offset;
                                                 tmp =  (int)( symbol_entry->symbol->st_value);
                                                *(int *)refptr =  tmp;
                                        }else if(symbol_entry->symbol->st_shndx == 2){
                                        //      refptr = data + (int)rel->r_offset;
                                                tmp = (int)(  textsize + (int)symbol_entry->symbol->st_value);
                                                *(int *)refptr =  tmp;
                                        }

                                }else{
                                        printf("\n%d type not supported\n",(int)ELF32_ST_TYPE(rel->r_info));
                                        exit(1);
                                }
                                printf(" After relocation its value is 0x%x \n", tmp);
                        }
                }
        }
}

void main(int argc, char *argv[]){

        Node *undefined_object_file1, *undefined_object_file2 , *undefined_object_file3;
        Node *defined_object_file1, *defined_object_file2 ,*defined_object_file3;
        
        init(&undefined_object_file1);
        init(&defined_object_file1);
        init(&undefined_object_file2);
        init(&defined_object_file2);
        init(&undefined_object_file3);
        init(&defined_object_file3);
        
        int fd1,fd2,fd3, type,bind,fsize;                       // File Descriptor
        char *base_ptr1, *base_ptr2, *base_ptr3;                        // ptr to our object in memory
        char *file = argv[1];                           // filename
        struct stat elf_stats;                          // fstat struct
        int i,j,size; char *name;
        unsigned int ret;
        Elf32_Rel rel;



        Elf *elf1, *elf2, *elf3;                        // Our Elf pointer for libelf 
        Elf32_Ehdr *elf_header1, *elf_header2 , *elf_header3;           // ELF header
        GElf_Shdr shdr;                                 // Section Header
        Elf_Scn *scn;                                   // Section Descriptor

        if((fd1 = open(argv[1], 0)) < 0)                //open first elf file
        {
                printf("couldnt open %s\n", argv[1]);
                exit(1);
        }

        if((fd2 = open(argv[2], 0)) < 0)                //open second file
        {
                printf("couldnt open %s\n", argv[2]);
                exit(1);
        }
        if((fd3 = open(argv[3], 0)) < 0 )               //open second file
        {
                printf("couldnt open %s\n", argv[3]);
                exit(1);
        }

        if((fsize = fsstat(fd1, &elf_stats)) == -1 )
        {
                printf("could not fstat %sand %d fd = %d\n", argv[1],fsize,fd1);
                close(fd1);
                exit(1);
        }

        if((base_ptr1 = (char *) malloc(fsize+2)) == (void*)0)
        {
                printf("could not malloc\n");
                close(fd1);
                exit(1);
        }
        if((read(fd1, base_ptr1, fsize)) == -3)
        {
                printf("could not read %s and size is %d\n", argv[1],fd1);
                free(base_ptr1);
                close(fd1);
                exit(1);
        }

        if((fsize = fsstat(fd2, &elf_stats)) == -1)
        {
                printf("could not fstat %s\n", argv[2]);
                close(fd2);
                exit(1);
        }

        if((base_ptr2 = (char *) malloc(fsize+2)) == (void*)0)
        {
                printf("could not malloc\n");
                close(fd2);
                exit(1);
        }


        if((read(fd2, base_ptr2, 20)) == -3)
        {
                printf("could not read %s\n", argv[2]);
                free(base_ptr2);
                close(fd2);
                exit(1);
        }
        if((fsize = fsstat(fd3, &elf_stats)) == -1)
        {
                printf("could not fstat %s\n", argv[3]);
                close(fd3);
                exit(1);
        }

        if((base_ptr3 = (char *) malloc(fsize+2)) == (void*)0)
        {
                printf("could not malloc\n");
                close(fd3);
                exit(1);
        }


        if((read(fd3, base_ptr3, fsize)) == -3)
        {
                printf("could not read %s\n", argv[3]);
                free(base_ptr3);
                close(fd3);
                exit(1);
        }
        /* Check libelf version first */
        if(elf_version(EV_CURRENT) == EV_NONE)
        {
                printf("WARNING Elf Library is out of date!\n");
        }
        // READ text and data sections
        char *text1,*text2,*text3,*data1,*data2,*data3,*bss1,*bss2;
        int textsize,datasize,bsssize;  

        elf_header1 = (Elf32_Ehdr *) base_ptr1; // point elf_header at our object in memory
        elf_header2 = (Elf32_Ehdr *) base_ptr2; // point elf_header at our object in memory
        elf_header3 = (Elf32_Ehdr *) base_ptr3; // point elf_header at our object in memory
        

        printf("going to begin 1\n");
        elf1 = elf_begin(fd1,ELF_C_READ,NULL);
        if(!elf1)
                printf("problem in elf_begin\n");
        printf("return from begin 1\n");
        elf2 = elf_begin(fd2,ELF_C_READ,NULL);
        printf("return from begin 2\n");
        elf3 = elf_begin(fd3,ELF_C_READ,NULL);
        printf("return from begin 3\n");

        printf("going to undefined symbols \n");
        get_undefined_entries(elf1,&undefined_object_file1,&defined_object_file1,0);
        printf("return from undefiend 1\n");
        get_undefined_entries(elf2,&undefined_object_file2,&defined_object_file2,1);
        printf("return from undefiend 2\n");
        get_undefined_entries(elf3,&undefined_object_file3,&defined_object_file3,2);
        printf("return from undefiend 3\n");

        printf("\nDefined Symbol list of object file 1\n");
        traverse(defined_object_file1);
        printf("\nDefined Symbol list of object file 2\n");
        traverse(defined_object_file2);
        printf("\nDefined Symbol list of object file 3\n");
        traverse(defined_object_file3);
        
        printf("\nUndefined Symbol list of object file 1\n");
        traverse(undefined_object_file1);
        printf("\nUndefined Symbol list of object file 2\n");
        traverse(undefined_object_file2);
        printf("\nUndefined Symbol list of object file 2\n");
        traverse(undefined_object_file2);

        /*resolve all undefined entries */      
        resolve_undefined_reference(&undefined_object_file1,&defined_object_file1,&defined_object_file2,&undefined_object_file2);
        resolve_undefined_reference(&undefined_object_file1,&defined_object_file1,&defined_object_file3,&undefined_object_file3);
        resolve_undefined_reference(&undefined_object_file2,&defined_object_file2,&defined_object_file1,&undefined_object_file1);
        resolve_undefined_reference(&undefined_object_file2,&defined_object_file2,&defined_object_file3,&undefined_object_file3);

        text1 = get_section_content(elf1,&textsize,TEXT_INDEX);
        argtextsize[0] = textsize;
        text2 = get_section_content(elf2,&textsize,TEXT_INDEX);
        argtextsize[1] = textsize;
        text3 = get_section_content(elf3,&textsize,TEXT_INDEX);
        argtextsize[2] = textsize;

        data1 = get_section_content(elf1,&datasize,DATA_INDEX);
        argdatasize[0] = datasize;
        printf("datasize is for 1 %d\n",datasize);
        data2 = get_section_content(elf2,&datasize,DATA_INDEX);
        argdatasize[1] = datasize;
        printf("datasize is for 2 %d\n",datasize);
        data3 = get_section_content(elf3,&datasize,DATA_INDEX);
        argdatasize[2] = datasize;
        printf("datasize is for 3 %d\n",datasize);
                
        for(j = 0 ; j < argdatasize[0] ; j++)
               printf("%x ",(char)*(data1 + j));        
                printf("\n\n\n");
        for(j = 0 ; j < argdatasize[1] ; j++)
               printf("%x ",(char)*(data2 + j));        
                printf("\n\n\n");
        for(j = 0 ; j < argdatasize[2] ; j++)
               printf("%x ",(char)*(data3 + j));        
                printf("\n\n\n");

        

        char *finaltext = (char *)malloc(sizeof(char) * (ALIGN(argtextsize[0]) + ALIGN(argtextsize[1]) + ALIGN(argtextsize[2])));
        char *finaldata = (char *)malloc(sizeof(char) * (ALIGN(argdatasize[0]) + ALIGN(argdatasize[1]) + ALIGN(argdatasize[2])));

        update(&undefined_object_file1,&defined_object_file1);
        update(&undefined_object_file2,&defined_object_file2);
        printf("After update\n");
        for(j = 0 ; j < argdatasize[0] ; j++)
               printf("%x ",(char)*(data1 + j));        
                printf("\n\n\n");
        for(j = 0 ; j < argdatasize[1] ; j++)
               printf("%x ",(char)*(data2 + j));        
                printf("\n\n\n");
        for(j = 0 ; j < argdatasize[2] ; j++)
               printf("%x ",(char)*(data3 + j));        
                printf("\n\n\n");

        if(definition_not_found(undefined_object_file1) || definition_not_found(undefined_object_file2))
                exit(1);

        for( i = 0 ; i < argdatasize[0] ; i++)
                *(finaldata + i ) = *(data1 + i);
        for( i = argdatasize[0] ; i < ALIGN(argdatasize[0]) ; i++)
                *(finaldata + i) = 0;

        for( i = 0 ; i < argdatasize[1] ; i++)
                *(finaldata + ALIGN(argdatasize[0]) + i ) = *(data2 + i);
        for( i = argdatasize[1] ; i < ALIGN(argdatasize[0]) + ALIGN(argdatasize[1]) ; i++)
                *(finaldata + ALIGN(argdatasize[0]) + i) = 0;

        for( i = 0 ; i < argdatasize[2] ; i++)
                *(finaldata + ALIGN(argdatasize[0])+ALIGN(argdatasize[1]) + i) = *(data3 + i);
        
        printf("prashant\n");
        for(j = 0 ; j < argdatasize[0] ; j++)
               printf("%x ",(char)*(data1 + j));        
                printf("\n\n\n");
        for(j = 0 ; j < argdatasize[1] ; j++)
               printf("%x ",(char)*(data2 + j));        
                printf("\n\n\n");
        for(j = 0 ; j < argdatasize[2] ; j++)
               printf("%x ",(char)*(data3 + j));        
                printf("\n\n\n");

        
        for( i = 0 ; i < argtextsize[0] ; i++)
                *(finaltext + i ) = *(text1 + i);
        for( i = argtextsize[0] ; i < ALIGN(argtextsize[0]) ; i++)
                *(finaltext + i) = 0x90;

        for( i = 0 ; i < argtextsize[1] ; i++)
                *(finaltext + ALIGN(argtextsize[0]) + i) = *(text2 + i);
        for( i = argtextsize[1] ; i < (ALIGN(argtextsize[0]) + ALIGN(argtextsize[1])) ; i++)
                *(finaltext + ALIGN(argtextsize[0]) + i) = 0x90;

        for( i = 0 ; i < argtextsize[2] ; i++)
                *(finaltext + ALIGN(argtextsize[0]) + ALIGN(argtextsize[1])+ i) = *(text3 + i);
        for( i = argtextsize[2] ; i < (ALIGN(argtextsize[0]) + ALIGN(argtextsize[1]) + ALIGN(argtextsize[2])) ; i++)
                *(finaltext + ALIGN(argtextsize[0])+ALIGN(argtextsize[1]) + i) = 0;
/*      
        printf("prashant\n");
        for(j = 0 ; j < argdatasize[0] ; j++)
               printf("%x ",(char)*(data1 + j));        
                printf("\n\n\n");
        for(j = 0 ; j < argdatasize[1] ; j++)
               printf("%x ",(char)*(data2 + j));        
                printf("\n\n\n");
        for(j = 0 ; j < argdatasize[2] ; j++)
               printf("%x ",(char)*(data3 + j));        
                printf("\n\n\n");

        
        for( i = 0 ; i < argdatasize[0] ; i++)
                *(finaldata + i ) = *(data1 + i);
        for( i = argdatasize[0] ; i < ALIGN(argdatasize[0]) ; i++)
                *(finaldata + i) = 0;

        for( i = 0 ; i < argdatasize[1] ; i++)
                *(finaldata + ALIGN(argdatasize[0]) + i ) = *(data2 + i);
        for( i = argdatasize[1] ; i < ALIGN(argdatasize[0]) + ALIGN(argdatasize[1]) ; i++)
                *(finaldata + ALIGN(argdatasize[0]) + i) = 0;

        for( i = 0 ; i < argdatasize[2] ; i++)
                *(finaldata + ALIGN(argdatasize[0])+ALIGN(argdatasize[1]) + i) = *(data3 + i);
*/
                for(j = 0 ; j < argdatasize[0] ; j++)
                       printf("%x ",(char)*(data1 + j));        
                printf("\n\n\n");
                for(j = 0 ; j < argdatasize[1] ; j++)
                       printf("%x ",(char)*(data2 + j));        
                printf("\n\n\n");
                for(j = 0 ; j < argdatasize[2] ; j++)
                       printf("%x ",(char)*(data3 + j));        
                printf("\n\n\n");

        printf("\nRelocation of symbols in object file1\n");

        do_relocation(elf1,defined_object_file1,finaltext,finaldata,ALIGN(argtextsize[0]) + ALIGN(argtextsize[1]) + ALIGN(argtextsize[2]),0,0);
        printf("\nRelocation of symbols in object file2\n");

        do_relocation(elf2,defined_object_file2,finaltext,finaldata,ALIGN(argtextsize[0]) + ALIGN(argtextsize[1]) + ALIGN(argtextsize[2]),ALIGN(argtextsize[0]),ALIGN(argdatasize[0]));


/*      do_relocation(elf2,defined_object_file2,finaltext,finaldata,ALIGN(argtextsize[0]) + ALIGN(argtextsize[1]) + ALIGN(argtextsize[2]),ALIGN(argtextsize[0]) + ALIGN(argtextsize[2]), ALIGN(argdatasize[0]) + ALIGN(argdatasize[2]));
*/


        int pfdr , pfdw;
        char pbuf[96];
        pfdr = open(argv[4],O_RDONLY );
        pfdw = open(argv[5],O_WRONLY|O_CREATE|O_RDONLY);
        read(pfdr,pbuf,96);

        *(int*)(header_buf+0x44) = ALIGN(argtextsize[0]) + ALIGN(argtextsize[1]) +ALIGN(argtextsize[2])+ ALIGN(argdatasize[0]) +ALIGN(argdatasize[1]) + argdatasize[2];//filesz
        *(int*)(header_buf+0x48) = ALIGN(argtextsize[0]) + ALIGN(argtextsize[1]) +ALIGN(argtextsize[2])+ ALIGN(argdatasize[0]) +ALIGN(argdatasize[1]) + argdatasize[2];//memsz

        printf("\n");
        

        printf("\n");
        write(pfdw,header_buf,96);
        write(pfdw,finaltext,ALIGN(argtextsize[0])+ALIGN(argtextsize[1])+ALIGN(argtextsize[2]));
        write(pfdw,finaldata,ALIGN(argdatasize[0])+ALIGN(argdatasize[1])+ALIGN(argdatasize[2]));
        close(pfdw);
        exit(1);
}