kml_decode.c

嵌入式系统设计与实验教材二源码linux内核移植与编译

        CDEBUG (D_KML, "     new_objv::%s\n", kml_version (&rec->new_objectv));
        CDEBUG (D_KML, "     uid::%d\n", rec->uid);
        CDEBUG (D_KML, "     gid::%d\n", rec->gid);
}

static void print_kml_rename (struct kml_rename *rec)
{
        CDEBUG (D_KML, " === RENAME\n");
        CDEBUG (D_KML, "     s-path::%s\n", rec->sourcepath);
        CDEBUG (D_KML, "     t-path::%s\n", rec->targetpath);
        CDEBUG (D_KML, "     old_tgtv::%s\n", kml_version (&rec->old_tgtv));
        CDEBUG (D_KML, "     new_tgtv::%s\n", kml_version (&rec->new_tgtv));
        CDEBUG (D_KML, "     new_objv::%s\n", kml_version (&rec->new_objectv));
        CDEBUG (D_KML, "     old_objv::%s\n", kml_version (&rec->old_objectv));
}

static void print_kml_setattr (struct kml_setattr *rec)
{
        CDEBUG (D_KML, " === SETATTR\n");
        CDEBUG (D_KML, "     path::%s\n", rec->path);
        CDEBUG (D_KML, "     old_objv::%s\n", kml_version (&rec->old_objectv));
        CDEBUG (D_KML, "     valid::0x%x\n", rec->iattr.ia_valid);
        CDEBUG (D_KML, "     mode::%o\n", rec->iattr.ia_mode);
        CDEBUG (D_KML, "     uid::%d\n", rec->iattr.ia_uid);
        CDEBUG (D_KML, "     gid::%d\n", rec->iattr.ia_gid);
        CDEBUG (D_KML, "     size::%u\n", (u32) rec->iattr.ia_size);
        CDEBUG (D_KML, "     mtime::%u\n", (u32) rec->iattr.ia_mtime);
        CDEBUG (D_KML, "     ctime::%u\n", (u32) rec->iattr.ia_ctime);
        CDEBUG (D_KML, "     flags::%u\n", (u32) rec->iattr.ia_attr_flags);
}

static void print_kml_link (struct kml_link *rec)
{
        CDEBUG (D_KML, " === LINK\n");
        CDEBUG (D_KML, "     path::%s ==> %s\n", rec->sourcepath, rec->targetpath);
        CDEBUG (D_KML, "     old_parv::%s\n", kml_version (&rec->old_parentv));
        CDEBUG (D_KML, "     new_obj::%s\n", kml_version (&rec->new_objectv));
        CDEBUG (D_KML, "     new_parv::%s\n", kml_version (&rec->new_parentv));
}

static void print_kml_mknod (struct kml_mknod *rec)
{
        CDEBUG (D_KML, " === MKNOD\n");
        CDEBUG (D_KML, "     path::%s\n", rec->path);
        CDEBUG (D_KML, "     new_obj::%s\n", kml_version (&rec->new_objectv));
        CDEBUG (D_KML, "     old_parv::%s\n", kml_version (&rec->old_parentv));
        CDEBUG (D_KML, "     new_parv::%s\n", kml_version (&rec->new_parentv));
        CDEBUG (D_KML, "     mode::%o\n", rec->mode);
        CDEBUG (D_KML, "     uid::%d\n", rec->uid);
        CDEBUG (D_KML, "     gid::%d\n", rec->gid);
        CDEBUG (D_KML, "     major::%d\n", rec->major);
        CDEBUG (D_KML, "     minor::%d\n", rec->minor);
}

static void print_kml_open (struct kml_open *rec)
{
        CDEBUG (D_KML, " === OPEN\n");
}

#if 0
static void print_kml_endmark (struct kml_endmark *rec)
{
        int i;
        CDEBUG (D_KML, " === ENDMARK\n");
        CDEBUG (D_KML, "     total::%u\n", rec->total);
        for (i = 0; i < rec->total; i++)
        {       
                CDEBUG (D_KML, "         recno=%ld::flag=%ld,op=%ld, i_ino=%ld, \
                        i_nlink=%ld\n", (long) rec->kop[i].kml_recno, 
                        (long) rec->kop[i].kml_flag, (long) rec->kop[i].kml_op, 
                        (long) rec->kop[i].i_ino, (long) rec->kop[i].i_nlink);
        }
}
#endif

static void print_kml_optimize (struct kml_optimize  *rec)
{
        CDEBUG (D_KML, " === OPTIMIZE\n");
        if (rec->kml_flag == KML_REC_DELETE)
                CDEBUG (D_KML, "     kml_flag::deleted\n");
        else
                CDEBUG (D_KML, "     kml_flag::exist\n");
        CDEBUG (D_KML, "     kml_op::%u\n", rec->kml_op);
        CDEBUG (D_KML, "     i_nlink::%d\n", rec->i_nlink);
        CDEBUG (D_KML, "     i_ino::%u\n", rec->i_ino);
}

static void print_kml_suffix (struct journal_suffix *tail)
{
        CDEBUG (D_KML, " === KML SUFFIX\n");
        CDEBUG (D_KML, "     prevrec::%ld\n", tail->prevrec);
        CDEBUG (D_KML, "     recno::%ld\n", (long) tail->recno);
        CDEBUG (D_KML, "     time::%d\n", tail->time);
        CDEBUG (D_KML, "     len::%d\n", tail->len);
}

void kml_printrec (struct kml_rec *rec, int kml_printop)
{
        if (kml_printop & PRINT_KML_PREFIX)
                print_kml_prefix (&rec->rec_head);
        if (kml_printop & PRINT_KML_REC) 
        { 
                switch (rec->rec_head.opcode)
                {
                        case KML_CREATE:
                                print_kml_create (&rec->rec_kml.create);
                                break;
                        case KML_MKDIR:
                                print_kml_mkdir (&rec->rec_kml.mkdir);
                                break;
                        case KML_UNLINK:
                                print_kml_unlink (&rec->rec_kml.unlink);
                                break;
                        case KML_RMDIR:
                                print_kml_rmdir (&rec->rec_kml.rmdir);
                                break;
                        case KML_CLOSE:
                                print_kml_close (&rec->rec_kml.close);
                                break;
                        case KML_SYMLINK:
                                print_kml_symlink (&rec->rec_kml.symlink);
                                break;
                        case KML_RENAME:
                                print_kml_rename (&rec->rec_kml.rename);
                                break;
                        case KML_SETATTR:
                                print_kml_setattr (&rec->rec_kml.setattr);
                                break;
                        case KML_LINK:
                                print_kml_link (&rec->rec_kml.link);
                                break;
                        case KML_OPEN:
                                print_kml_open (&rec->rec_kml.open);
                                break;
                        case KML_MKNOD:
                                print_kml_mknod (&rec->rec_kml.mknod);
                                break;
#if 0
                        case KML_ENDMARK:
                                print_kml_endmark (&rec->rec_kml.endmark);
#endif
                                break;
                        default:
                                CDEBUG (D_KML, " === BAD RECORD, opcode=%u\n",
                                        rec->rec_head.opcode);
                                break;
                }
        }
        if (kml_printop & PRINT_KML_SUFFIX)
                print_kml_suffix (&rec->rec_tail);
        if (kml_printop & PRINT_KML_OPTIMIZE)
                print_kml_optimize (&rec->kml_optimize);
}

void kml_freerec (struct kml_rec *rec)
{
        char *sourcepath = NULL,
             *targetpath = NULL;
        switch (rec->rec_head.opcode)
        {
                case KML_CREATE:
                        sourcepath = rec->rec_kml.create.path;
                        break;
                case KML_MKDIR:
                        sourcepath = rec->rec_kml.create.path;
                        break;
                case KML_UNLINK:
                        sourcepath = rec->rec_kml.unlink.path;
                        targetpath = rec->rec_kml.unlink.name;
                        break;
                case KML_RMDIR:
                        sourcepath = rec->rec_kml.rmdir.path;
                        targetpath = rec->rec_kml.rmdir.name;
                        break;
                case KML_CLOSE:
                        sourcepath = rec->rec_kml.close.path;
                        break;
                case KML_SYMLINK:
                        sourcepath = rec->rec_kml.symlink.sourcepath;
                        targetpath = rec->rec_kml.symlink.targetpath;
                        break;
                case KML_RENAME:
                        sourcepath = rec->rec_kml.rename.sourcepath;
                        targetpath = rec->rec_kml.rename.targetpath;
                        break;
                case KML_SETATTR:
                        sourcepath = rec->rec_kml.setattr.path;
                        break;
                case KML_LINK:
                        sourcepath = rec->rec_kml.link.sourcepath;
                        targetpath = rec->rec_kml.link.targetpath;
                        break;
                case KML_OPEN:
                        break;
                case KML_MKNOD:
                        sourcepath = rec->rec_kml.mknod.path;
                        break;
#if 0
                case KML_ENDMARK:
                        PRESTO_FREE (rec->rec_kml.endmark.kop, sizeof (int) + 
                                sizeof (struct kml_kop_node) * 
                                rec->rec_kml.endmark.total);
#endif
                        break;
                default:
                        break;
        }
        if (sourcepath != NULL)
                PRESTO_FREE (sourcepath, strlen (sourcepath) + 1);
        if (targetpath != NULL)
                PRESTO_FREE (targetpath, strlen (targetpath) + 1);
}

char *readrec (char *recbuf, int reclen, int pos, int *size)
{
        char *p = recbuf + pos;
        *size = *((int *) p);
        if (*size > (reclen - pos))
            return NULL;
        return p; 
}

int kml_decoderec (char *buf, int pos, int buflen, int *size, 
                        struct kml_rec **newrec)
{
        char *tmp;
        int  error;
        tmp = readrec (buf, buflen, pos, size);
        if (tmp == NULL)
                return -EBADF;
        error = kml_unpack (tmp, *size, pos, newrec); 
        return error;
}

#if 0
static void fill_kmlrec_optimize (struct list_head *head, 
                struct kml_rec *optrec)
{
        struct kml_rec *kmlrec;
        struct list_head *tmp;
        struct kml_endmark *km;
        struct kml_optimize *ko;
        int    n;

        if (optrec->rec_kml.endmark.total == 0)
                return;
        n = optrec->rec_kml.endmark.total - 1;
        tmp = head->prev;
        km = &optrec->rec_kml.endmark;
        while ( n >= 0 && tmp != head ) 
        {
                kmlrec = list_entry(tmp, struct kml_rec,
                        kml_optimize.kml_chains);
                tmp = tmp->prev;
                if (kmlrec->rec_tail.recno == km->kop[n].kml_recno) 
                {
                        ko = &kmlrec->kml_optimize;
                        ko->kml_flag = km->kop[n].kml_flag;
                        ko->kml_op   = km->kop[n].kml_op;
                        ko->i_nlink  = km->kop[n].i_nlink;
                        ko->i_ino    = km->kop[n].i_ino;
                        n --;
                }
        }
        if (n != -1)
                CDEBUG (D_KML, "Yeah!!!, KML optimize error, recno=%d, n=%d\n",
                        optrec->rec_tail.recno, n);     
}
#endif

int decode_kmlrec (struct list_head *head, char *kml_buf, int buflen)
{
        struct kml_rec *rec;
        int    pos = 0, size;
        int    err;
        while (pos < buflen) {
                err = kml_decoderec (kml_buf, pos, buflen, &size, &rec);
                if (err != 0)
                        break;
#if 0
                if (rec->rec_head.opcode == KML_ENDMARK) {
                        fill_kmlrec_optimize (head, rec);
                        mark_rec_deleted (rec);
                }
#endif
                list_add_tail (&rec->kml_optimize.kml_chains, head);
                pos += size;
        }
        return err;
}

int delete_kmlrec (struct list_head *head)
{
        struct kml_rec *rec;
        struct list_head *tmp;

        if (list_empty(head))
                return 0;
        tmp = head->next;
        while ( tmp != head ) {
                rec = list_entry(tmp, struct kml_rec, 
                        kml_optimize.kml_chains);
                tmp = tmp->next;
                kml_freerec (rec);
        }
        INIT_LIST_HEAD(head);
        return 0;
}

int print_allkmlrec (struct list_head *head, int printop)
{
        struct kml_rec *rec;
        struct list_head *tmp;

        if (list_empty(head))
                return 0;
        tmp = head->next;
        while ( tmp != head ) {
                rec = list_entry(tmp, struct kml_rec,
                        kml_optimize.kml_chains);
                tmp = tmp->next;
#if 0
                if (printop & PRINT_KML_EXIST) {
                        if (is_deleted_node (rec))
                                continue;
                }
                else if (printop & PRINT_KML_DELETE) {
                        if (! is_deleted_node (rec))
                                continue;
                }
#endif
                kml_printrec (rec, printop);
        }
        INIT_LIST_HEAD(head);
        return 0;
}