kml_decode.c

《嵌入式系统设计与实例开发实验教材二源码》Linux内核移植与编译实验

        p = dlogit (&rec->old_tgtv, p, sizeof (struct presto_version));
        p = dlogit (&pathlen, p, sizeof (int));
        p = dlogit (&targetlen, p, sizeof (int));

        PRESTO_ALLOC(q, char *, pathlen + 1);
        if (q == NULL) {
                EXIT;
                return -ENOMEM;
        }

        memcpy (q, p, pathlen);
        q[pathlen] = '\0';
        rec->sourcepath = q;
        p += size_round (pathlen);

        PRESTO_ALLOC(q, char *, targetlen + 1);
        if (q == NULL) {
                PRESTO_FREE (rec->sourcepath, pathlen + 1);
                EXIT;
                return -ENOMEM;
        }

        memcpy (q, p, targetlen);
        q[targetlen] = '\0';
        rec->targetpath = q;

        *rec_offs = pos + unpack_size + size_round(pathlen) +
                        size_round(targetlen);
        EXIT;
        return 0;
}

static int unpack_unlink (struct kml_unlink *rec, char *buf, 
                                int pos, int *rec_offs)
{
        char *p, *q;
        int unpack_size = 80;
        int pathlen, targetlen;

        ENTRY;
        p = buf + pos;
        p = dlogit (&rec->old_parentv, p, sizeof (struct presto_version));
        p = dlogit (&rec->new_parentv, p, sizeof (struct presto_version));
        p = dlogit (&rec->old_tgtv, p, sizeof (struct presto_version));
        p = dlogit (&pathlen, p, sizeof (int));
        p = dlogit (&targetlen, p, sizeof (int));

        PRESTO_ALLOC(q, char *, pathlen + 1);
        if (q == NULL) {
                EXIT;
                return -ENOMEM;
        }

        memcpy (q, p, pathlen);
        q[pathlen] = '\0';
        rec->path = q;
        p += size_round (pathlen);

        PRESTO_ALLOC(q, char *, targetlen + 1);
        if (q == NULL) {
                PRESTO_FREE (rec->path, pathlen + 1);
                EXIT;
                return -ENOMEM;
        }

        memcpy (q, p, targetlen);
        q[targetlen] = '\0';
        rec->name = q;

        /* fix the presto_journal_unlink problem */
        *rec_offs = pos + unpack_size + size_round(pathlen) +
                        size_round(targetlen);
        EXIT;
        return 0;
}

static int unpack_rmdir (struct kml_rmdir *rec, char *buf, 
                                int pos, int *rec_offs)
{
        char *p, *q;
        int unpack_size = 80;
        int pathlen, targetlen;

        ENTRY;
        p = buf + pos;
        p = dlogit (&rec->old_parentv, p, sizeof (struct presto_version));
        p = dlogit (&rec->new_parentv, p, sizeof (struct presto_version));
        p = dlogit (&rec->old_tgtv, p, sizeof (struct presto_version));
        p = dlogit (&pathlen, p, sizeof (int));
        p = dlogit (&targetlen, p, sizeof (int));

        PRESTO_ALLOC(q, char *, pathlen + 1);
        if (q == NULL) {
                EXIT;
                return -ENOMEM;
        }

        memcpy (q, p, pathlen);
        q[pathlen] = '\0';
        rec->path = q;
        p += size_round (pathlen);

        PRESTO_ALLOC(q, char *, targetlen + 1);
        if (q == NULL) {
                PRESTO_FREE (rec->path, pathlen + 1);
                EXIT;
                return -ENOMEM;
        }
        memcpy (q, p, targetlen);
        q[targetlen] = '\0';
        rec->name = q;

        *rec_offs = pos + unpack_size + size_round(pathlen) +
                        size_round(targetlen);
        EXIT;
        return 0;
}

static int unpack_setattr (struct kml_setattr *rec, char *buf, 
                                int pos, int *rec_offs)
{
        char *p, *q;
        int unpack_size = 72;
        struct kml_attr {
                __u64   size, mtime, ctime;
        } objattr;
        int     valid, mode, uid, gid, flags;
        int pathlen;

        ENTRY;
        p = buf + pos;
        p = dlogit (&rec->old_objectv, p, sizeof (struct presto_version));
        p = dlogit (&valid, p, sizeof (int));
        p = dlogit (&mode, p, sizeof (int));
        p = dlogit (&uid, p, sizeof (int));
        p = dlogit (&gid, p, sizeof (int));
        p = dlogit (&objattr, p, sizeof (struct kml_attr));
        p = dlogit (&flags, p, sizeof (int));
        p = dlogit (&pathlen, p, sizeof (int));

        rec->iattr.ia_valid = valid;
        rec->iattr.ia_mode = mode;
        rec->iattr.ia_uid = uid;
        rec->iattr.ia_gid = gid;
        rec->iattr.ia_size = objattr.size;
        rec->iattr.ia_mtime = objattr.mtime;
        rec->iattr.ia_ctime = objattr.ctime;
        rec->iattr.ia_atime = 0;
        rec->iattr.ia_attr_flags = flags;

        PRESTO_ALLOC(q, char *, pathlen + 1);
        if (q == NULL) {
                EXIT;
                return -ENOMEM;
        }
        memcpy (q, p, pathlen);
        q[pathlen] = '\0';
        rec->path = q;
        p += pathlen;

        *rec_offs = pos + unpack_size + size_round(pathlen);
        EXIT;
        return 0;
}

static int unpack_close (struct kml_close *rec, char *buf, 
                                int pos, int *rec_offs)
{
        char *p, *q;
        int unpack_size = 52;
        int pathlen;

        ENTRY;
        p = buf + pos;
        p = dlogit (&rec->open_mode, p, sizeof (int));
        p = dlogit (&rec->open_uid, p, sizeof (int));
        p = dlogit (&rec->open_gid, p, sizeof (int));
        p = dlogit (&rec->new_objectv, p, sizeof (struct presto_version));
        p = dlogit (&rec->ino, p, sizeof (__u64));
        p = dlogit (&rec->generation, p, sizeof (int));
        p = dlogit (&pathlen, p, sizeof (int));

        PRESTO_ALLOC(q, char *, pathlen + 1);
        if (q == NULL) {
                EXIT;
                return -ENOMEM;
        }

        memcpy (q, p, pathlen);
        q[pathlen] = '\0';
        rec->path = q;
        p += pathlen;

        *rec_offs = pos + unpack_size + size_round(pathlen);
        EXIT;
        return 0;
}

static int unpack_mkdir (struct kml_mkdir *rec, char *buf, 
                                int pos, int *rec_offs)
{
        char *p, *q;
        int unpack_size = 88;
        int pathlen;

        ENTRY;
        p = buf + pos;
        p = dlogit (&rec->old_parentv, p, sizeof (struct presto_version));
        p = dlogit (&rec->new_parentv, p, sizeof (struct presto_version));
        p = dlogit (&rec->new_objectv, p, sizeof (struct presto_version));
        p = dlogit (&rec->mode, p, sizeof (int));
        p = dlogit (&rec->uid, p, sizeof (int));
        p = dlogit (&rec->gid, p, sizeof (int));
        p = dlogit (&pathlen, p, sizeof (int));

        PRESTO_ALLOC(q, char *, pathlen + 1);
        if (q == NULL) {
                EXIT;
                return -ENOMEM;
        }

        memcpy (q, p, pathlen);
        q[pathlen] = '\0';
        rec->path = q;
        p += pathlen;

        *rec_offs = pos + unpack_size + size_round(pathlen);
        EXIT;
        return 0;
}

#if 0
static int unpack_endmark (struct kml_endmark *rec, char *buf, 
                                int pos, int *rec_offs)
{
        char *p;
        p = buf + pos;
        p = dlogit (&rec->total, p, sizeof (int));

        PRESTO_ALLOC (rec->kop, struct kml_kop_node *, 
                        sizeof (struct kml_kop_node) * rec->total);
        if (rec->kop == NULL) {
                EXIT;
                return -ENOMEM;
        }

        p = dlogit (rec->kop, p, sizeof (struct kml_kop_node) * rec->total);

        *rec_offs = pos + sizeof (int) + sizeof (struct kml_kop_node) * rec->total;
        return 0;
}
#endif

static char *kml_version (struct presto_version *ver)
{
        static char buf[256];
        sprintf (buf, "mt::%lld, ct::%lld, size::%lld",
                ver->pv_mtime, ver->pv_ctime, ver->pv_size); 
        return buf;
}

static void print_kml_prefix (struct big_journal_prefix *head)
{
        int i;

        CDEBUG (D_KML, " === KML PREFIX\n");
        CDEBUG (D_KML, "     len        = %u\n", head->len);
        CDEBUG (D_KML, "     version    = %u\n", head->version);
        CDEBUG (D_KML, "     pid        = %u\n", head->pid);
        CDEBUG (D_KML, "     uid        = %u\n", head->uid);
        CDEBUG (D_KML, "     fsuid      = %u\n", head->fsuid);
        CDEBUG (D_KML, "     fsgid      = %u\n", head->fsgid);
        CDEBUG (D_KML, "     opcode     = %u\n", head->opcode);
        CDEBUG (D_KML, "     ngroup     = %u",  head->ngroups);
        for (i = 0; i < head->ngroups; i++)
                CDEBUG (D_KML, "%u  ",  head->groups[i]);
        CDEBUG (D_KML, "\n");
}

static void print_kml_create (struct kml_create *rec)
{
        CDEBUG (D_KML, " === CREATE\n");
        CDEBUG (D_KML, "     path::%s\n", rec->path);
        CDEBUG (D_KML, "     new_objv::%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);
}

static void print_kml_mkdir (struct kml_mkdir *rec)
{
        CDEBUG (D_KML, " === MKDIR\n");
        CDEBUG (D_KML, "     path::%s\n", rec->path);
        CDEBUG (D_KML, "     new_objv::%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);
}

static void print_kml_unlink (struct kml_unlink *rec)
{
        CDEBUG (D_KML, " === UNLINK\n");
        CDEBUG (D_KML, "     path::%s/%s\n", rec->path, rec->name);
        CDEBUG (D_KML, "     old_tgtv::%s\n", kml_version (&rec->old_tgtv));
        CDEBUG (D_KML, "     old_parv::%s\n", kml_version (&rec->old_parentv));
        CDEBUG (D_KML, "     new_parv::%s\n", kml_version (&rec->new_parentv));
}

static void print_kml_rmdir (struct kml_rmdir *rec)
{
        CDEBUG (D_KML, " === RMDIR\n");
        CDEBUG (D_KML, "     path::%s/%s\n", rec->path, rec->name);
        CDEBUG (D_KML, "     old_tgtv::%s\n", kml_version (&rec->old_tgtv));
        CDEBUG (D_KML, "     old_parv::%s\n", kml_version (&rec->old_parentv));
        CDEBUG (D_KML, "     new_parv::%s\n", kml_version (&rec->new_parentv));
}

static void print_kml_close (struct kml_close *rec)
{
        CDEBUG (D_KML, " === CLOSE\n");
        CDEBUG (D_KML, "     mode::%o\n", rec->open_mode);
        CDEBUG (D_KML, "     uid::%d\n", rec->open_uid);
        CDEBUG (D_KML, "     gid::%d\n", rec->open_gid);
        CDEBUG (D_KML, "     path::%s\n", rec->path);
        CDEBUG (D_KML, "     new_objv::%s\n", kml_version (&rec->new_objectv));
        CDEBUG (D_KML, "     ino::%lld\n", rec->ino);
        CDEBUG (D_KML, "     gen::%u\n", rec->generation);
}

static void print_kml_symlink (struct kml_symlink *rec)
{
        CDEBUG (D_KML, " === SYMLINK\n");
        CDEBUG (D_KML, "     s-path::%s\n", rec->sourcepath);
        CDEBUG (D_KML, "     t-path::%s\n", rec->targetpath);
        CDEBUG (D_KML, "     old_parv::%s\n", kml_version (&rec->old_parentv));
        CDEBUG (D_KML, "     new_parv::%s\n", kml_version (&rec->new_parentv));