package/mtd/src/jffs2.c

   1 #include <sys/types.h>
   2 #include <sys/stat.h>
   3 #include <stdint.h>
   4 #include <stdio.h>
   5 #include <fcntl.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <dirent.h>
   9 #include <unistd.h>
  10 #include "jffs2.h"
  11 #include "crc32.h"
  12 #include "mtd.h"
  13
  14 #define PAD(x) (((x)+3)&~3)
  15
  16 #define CLEANMARKER "\x85\x19\x03\x20\x0c\x00\x00\x00\xb1\xb0\x1e\xe4"
  17 #define JFFS2_EOF "\xde\xad\xc0\xde"
  18
  19 static int last_ino = 0;
  20 static int last_version = 0;
  21 static char *buf = NULL;
  22 static int ofs = 0;
  23 static int outfd = 0;
  24 static int mtdofs = 0;
  25
  26 static void prep_eraseblock(void);
  27
  28 static void pad(int size)
  29 {
  30         if ((ofs % size == 0) && (ofs < erasesize))
  31                 return;
  32
  33         if (ofs < erasesize) {
  34                 memset(buf + ofs, 0xff, (size - (ofs % size)));
  35                 ofs += (size - (ofs % size));
  36         }
  37         ofs = ofs % erasesize;
  38         if (ofs == 0) {
  39                 mtd_erase_block(outfd, mtdofs);
  40                 write(outfd, buf, erasesize);
  41                 mtdofs += erasesize;
  42         }
  43 }
  44
  45 static inline int rbytes(void)
  46 {
  47         return erasesize - (ofs % erasesize);
  48 }
  49
  50 static inline void add_data(char *ptr, int len)
  51 {
  52         if (ofs + len > erasesize) {
  53                 pad(erasesize);
  54                 prep_eraseblock();
  55         }
  56         memcpy(buf + ofs, ptr, len);
  57         ofs += len;
  58 }
  59
  60 static void prep_eraseblock(void)
  61 {
  62         if (ofs > 0)
  63                 return;
  64
  65         add_data(CLEANMARKER, sizeof(CLEANMARKER) - 1);
  66 }
  67
  68 static int add_dirent(char *name, char type, int parent)
  69 {
  70         struct jffs2_raw_dirent *de;
  71
  72         if (ofs - erasesize < sizeof(struct jffs2_raw_dirent) + strlen(name))
  73                 pad(erasesize);
  74
  75         prep_eraseblock();
  76         last_ino++;
  77         memset(buf + ofs, 0, sizeof(struct jffs2_raw_dirent));
  78         de = (struct jffs2_raw_dirent *) (buf + ofs);
  79
  80         de->magic = JFFS2_MAGIC_BITMASK;
  81         de->nodetype = JFFS2_NODETYPE_DIRENT;
  82         de->type = type;
  83         de->name_crc = crc32(0, name, strlen(name));
  84         de->ino = last_ino++;
  85         de->pino = parent;
  86         de->totlen = sizeof(*de) + strlen(name);
  87         de->hdr_crc = crc32(0, (void *) de, sizeof(struct jffs2_unknown_node) - 4);
  88         de->version = last_version++;
  89         de->mctime = 0;
  90         de->nsize = strlen(name);
  91         de->node_crc = crc32(0, (void *) de, sizeof(*de) - 8);
  92         memcpy(de->name, name, strlen(name));
  93
  94         ofs += sizeof(struct jffs2_raw_dirent) + de->nsize;
  95         pad(4);
  96
  97         return de->ino;
  98 }
  99
 100 static int add_dir(char *name, int parent)
 101 {
 102         struct jffs2_raw_inode ri;
 103         int inode;
 104
 105         inode = add_dirent(name, IFTODT(S_IFDIR), parent);
 106
 107         if (rbytes() < sizeof(ri))
 108                 pad(erasesize);
 109         prep_eraseblock();
 110
 111         memset(&ri, 0, sizeof(ri));
 112         ri.magic = JFFS2_MAGIC_BITMASK;
 113         ri.nodetype = JFFS2_NODETYPE_INODE;
 114         ri.totlen = sizeof(ri);
 115         ri.hdr_crc = crc32(0, &ri, sizeof(struct jffs2_unknown_node) - 4);
 116
 117         ri.ino = inode;
 118         ri.mode = S_IFDIR | 0755;
 119         ri.uid = ri.gid = 0;
 120         ri.atime = ri.ctime = ri.mtime = 0;
 121         ri.isize = ri.csize = ri.dsize = 0;
 122         ri.version = 1;
 123         ri.node_crc = crc32(0, &ri, sizeof(ri) - 8);
 124         ri.data_crc = 0;
 125
 126         add_data((char *) &ri, sizeof(ri));
 127         pad(4);
 128         return inode;
 129 }
 130
 131 static void add_file(char *name, int parent)
 132 {
 133         int inode, f_offset = 0, fd;
 134         struct jffs2_raw_inode ri;
 135         struct stat st;
 136         char wbuf[4096], *fname;
 137         FILE *f;
 138
 139         if (stat(name, &st)) {
 140                 fprintf(stderr, "File %s does not exist\n", name);
 141                 return;
 142         }
 143
 144         fname = strrchr(name, '/');
 145         if (fname)
 146                 fname++;
 147         else
 148                 fname = name;
 149
 150         inode = add_dirent(name, IFTODT(S_IFREG), parent);
 151         memset(&ri, 0, sizeof(ri));
 152         ri.magic = JFFS2_MAGIC_BITMASK;
 153         ri.nodetype = JFFS2_NODETYPE_INODE;
 154
 155         ri.ino = inode;
 156         ri.mode = st.st_mode;
 157         ri.uid = ri.gid = 0;
 158         ri.atime = st.st_atime;
 159         ri.ctime = st.st_ctime;
 160         ri.mtime = st.st_mtime;
 161         ri.isize = st.st_size;
 162         ri.compr = 0;
 163         ri.usercompr = 0;
 164
 165         fd = open(name, 0);
 166         if (fd <= 0) {
 167                 fprintf(stderr, "File %s does not exist\n", name);
 168                 return;
 169         }
 170
 171         for (;;) {
 172                 int len = 0;
 173
 174                 for (;;) {
 175                         len = rbytes() - sizeof(ri);
 176                         if (len > 128)
 177                                 break;
 178
 179                         pad(erasesize);
 180                         prep_eraseblock();
 181                 }
 182
 183                 if (len > sizeof(wbuf))
 184                         len = sizeof(wbuf);
 185
 186                 len = read(fd, wbuf, len);
 187                 if (len <= 0)
 188                         break;
 189
 190                 ri.totlen = sizeof(ri) + len;
 191                 ri.hdr_crc = crc32(0, &ri, sizeof(struct jffs2_unknown_node) - 4);
 192                 ri.version = ++last_version;
 193                 ri.offset = f_offset;
 194                 ri.csize = ri.dsize = len;
 195                 ri.node_crc = crc32(0, &ri, sizeof(ri) - 8);
 196                 ri.data_crc = crc32(0, wbuf, len);
 197                 f_offset += len;
 198                 add_data((char *) &ri, sizeof(ri));
 199                 add_data(wbuf, len);
 200                 pad(4);
 201                 prep_eraseblock();
 202         }
 203
 204         close(fd);
 205 }
 206
 207 int mtd_write_jffs2(char *mtd, char *filename, char *dir)
 208 {
 209         int target_ino = 0;
 210         int err = -1, fdeof = 0;
 211         off_t offset;
 212
 213         outfd = mtd_check_open(mtd);
 214         if (!outfd)
 215                 return -1;
 216
 217         if (quiet < 2)
 218                 fprintf(stderr, "Appending %s to jffs2 partition %s\n", filename, mtd);
 219
 220         buf = malloc(erasesize);
 221         if (!buf) {
 222                 fprintf(stderr, "Out of memory!\n");
 223                 goto done;
 224         }
 225
 226         /* parse the structure of the jffs2 first
 227          * locate the directory that the file is going to be placed in */
 228         for(;;) {
 229                 struct jffs2_unknown_node *node = (struct jffs2_unknown_node *) buf;
 230                 unsigned int ofs = 0;
 231
 232                 if (read(outfd, buf, erasesize) != erasesize) {
 233                         fdeof = 1;
 234                         break;
 235                 }
 236                 mtdofs += erasesize;
 237
 238                 if (node->magic == 0x8519) {
 239                         fprintf(stderr, "Error: wrong endianness filesystem\n");
 240                         goto done;
 241                 }
 242
 243                 /* assume  no magic == end of filesystem
 244                  * the filesystem will probably end with be32(0xdeadc0de) */
 245                 if (node->magic != 0x1985)
 246                         break;
 247
 248                 while (ofs < erasesize) {
 249                         node = (struct jffs2_unknown_node *) (buf + ofs);
 250                         if (node->magic == 0x1985) {
 251                                 ofs += PAD(node->totlen);
 252                                 if (node->nodetype == JFFS2_NODETYPE_DIRENT) {
 253                                         struct jffs2_raw_dirent *de = (struct jffs2_raw_dirent *) node;
 254
 255                                         /* is this the right directory name and is it a subdirectory of / */
 256                                         if ((de->pino == 1) && !strncmp(de->name, dir, de->nsize))
 257                                                 target_ino = de->ino;
 258
 259                                         /* store the last inode and version numbers for adding extra files */
 260                                         if (last_ino < de->ino)
 261                                                 last_ino = de->ino;
 262                                         if (last_version < de->version)
 263                                                 last_version = de->version;
 264                                 }
 265                         } else {
 266                                 ofs = ~0;
 267                         }
 268                 }
 269         }
 270
 271         if (fdeof) {
 272                 fprintf(stderr, "Error: No room for additional data\n");
 273                 goto done;
 274         }
 275
 276         /* jump back one eraseblock */
 277         mtdofs -= erasesize;
 278         lseek(outfd, mtdofs, SEEK_SET);
 279
 280         ofs = 0;
 281
 282         if (!last_ino)
 283                 last_ino = 1;
 284
 285         if (!target_ino)
 286                 target_ino = add_dir(dir, 1);
 287
 288         add_file(filename, target_ino);
 289         pad(erasesize);
 290
 291         /* add eof marker, pad to eraseblock size and write the data */
 292         add_data(JFFS2_EOF, sizeof(JFFS2_EOF) - 1);
 293         pad(erasesize);
 294
 295         err = 0;
 296
 297 done:
 298         close(outfd);
 299         if (buf)
 300                 free(buf);
 301
 302         return err;
 303 }