224 lines
5.1 KiB
C
224 lines
5.1 KiB
C
/* Taken from Ted's losetup.c - Mitch <m.dsouza@mrc-apu.cam.ac.uk> */
|
|
|
|
/*
|
|
* losetup.c - setup and control loop devices
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <fcntl.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <sys/ioctl.h>
|
|
#include <linux/fs.h>
|
|
#include "loop.h"
|
|
|
|
char *crypt_name (int);
|
|
int crypt_type (char *);
|
|
void show_loop (char *);
|
|
int del_loop (const char *);
|
|
int set_loop (const char *, const char *, int offset, char *);
|
|
int lomount (const char *, const char *, const char *, char **,
|
|
int *, char **, char **);
|
|
|
|
struct crypt_type_struct {
|
|
int id;
|
|
char *name;
|
|
} crypt_type_tbl[] = {
|
|
|
|
{
|
|
LO_CRYPT_NONE, "no"
|
|
},
|
|
{
|
|
LO_CRYPT_NONE, "none"
|
|
},
|
|
{
|
|
LO_CRYPT_XOR, "xor"
|
|
},
|
|
{
|
|
LO_CRYPT_DES, "DES"
|
|
},
|
|
{
|
|
-1, NULL
|
|
}
|
|
};
|
|
|
|
char *
|
|
crypt_name (int id)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; crypt_type_tbl[i].id != -1; i++)
|
|
if (id == crypt_type_tbl[i].id)
|
|
return crypt_type_tbl[i].name;
|
|
return "undefined";
|
|
}
|
|
|
|
int
|
|
crypt_type (char *name)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; crypt_type_tbl[i].id != -1; i++)
|
|
if (!strcasecmp (name, crypt_type_tbl[i].name))
|
|
return crypt_type_tbl[i].id;
|
|
return -1;
|
|
}
|
|
|
|
void
|
|
show_loop (char *device)
|
|
{
|
|
struct loop_info loopinfo;
|
|
int fd;
|
|
|
|
if ((fd = open (device, O_RDWR)) < 0) {
|
|
fprintf(stderr, "loop: can't open device %s: %s\n",
|
|
device, strerror (errno));
|
|
return;
|
|
}
|
|
if (ioctl (fd, LOOP_GET_STATUS, &loopinfo) < 0) {
|
|
fprintf(stderr, "loop: can't get info on device %s: %s\n",
|
|
device, strerror (errno));
|
|
close (fd);
|
|
return;
|
|
}
|
|
printf ("%s: [%04x]:%ld (%s) offset %d, %s encryption\n",
|
|
device, loopinfo.lo_device, loopinfo.lo_inode,
|
|
loopinfo.lo_name, loopinfo.lo_offset,
|
|
crypt_name (loopinfo.lo_encrypt_type));
|
|
close (fd);
|
|
}
|
|
|
|
int
|
|
set_loop (const char *device, const char *file, int offset, char *encryption)
|
|
{
|
|
struct loop_info loopinfo;
|
|
int fd,
|
|
ffd,
|
|
i;
|
|
char *pass;
|
|
|
|
if ((fd = open (device, O_RDWR)) < 0) {
|
|
perror (device);
|
|
return 1;
|
|
}
|
|
if ((ffd = open (file, O_RDWR)) < 0) {
|
|
perror (file);
|
|
return 1;
|
|
}
|
|
memset (&loopinfo, 0, sizeof (loopinfo));
|
|
strncpy (loopinfo.lo_name, file, LO_NAME_SIZE);
|
|
loopinfo.lo_name[LO_NAME_SIZE - 1] = 0;
|
|
if (encryption && (loopinfo.lo_encrypt_type = crypt_type (encryption))
|
|
< 0) {
|
|
fprintf (stderr, "Unsupported encryption type %s", encryption);
|
|
return 1;
|
|
}
|
|
loopinfo.lo_offset = offset;
|
|
switch (loopinfo.lo_encrypt_type) {
|
|
case LO_CRYPT_NONE:
|
|
loopinfo.lo_encrypt_key_size = 0;
|
|
break;
|
|
case LO_CRYPT_XOR:
|
|
pass = getpass ("Password: ");
|
|
strncpy (loopinfo.lo_encrypt_key, pass, LO_KEY_SIZE);
|
|
loopinfo.lo_encrypt_key[LO_KEY_SIZE - 1] = 0;
|
|
loopinfo.lo_encrypt_key_size = strlen (loopinfo.lo_encrypt_key);
|
|
break;
|
|
case LO_CRYPT_DES:
|
|
pass = getpass ("Password: ");
|
|
strncpy (loopinfo.lo_encrypt_key, pass, 8);
|
|
loopinfo.lo_encrypt_key[8] = 0;
|
|
loopinfo.lo_encrypt_key_size = 8;
|
|
pass = getpass ("Init (up to 16 hex digits): ");
|
|
for (i = 0; i < 16 && pass[i]; i++)
|
|
if (isxdigit (pass[i]))
|
|
loopinfo.lo_init[i >> 3] |= (pass[i] > '9' ?
|
|
(islower (pass[i]) ? toupper (pass[i]) :
|
|
pass[i]) - 'A' + 10 : pass[i] - '0') << (i & 7) * 4;
|
|
else {
|
|
fprintf (stderr, "Non-hex digit '%c'.\n", pass[i]);
|
|
return 1;
|
|
}
|
|
break;
|
|
default:
|
|
fprintf (stderr,
|
|
"Don't know how to get key for encryption system %d\n",
|
|
loopinfo.lo_encrypt_type);
|
|
return 1;
|
|
}
|
|
if (ioctl (fd, LOOP_SET_FD, ffd) < 0) {
|
|
perror ("ioctl: LOOP_SET_FD");
|
|
return 1;
|
|
}
|
|
if (ioctl (fd, LOOP_SET_STATUS, &loopinfo) < 0) {
|
|
(void) ioctl (fd, LOOP_CLR_FD, 0);
|
|
perror ("ioctl: LOOP_SET_STATUS");
|
|
return 1;
|
|
}
|
|
close (fd);
|
|
close (ffd);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
del_loop (const char *device)
|
|
{
|
|
int fd;
|
|
|
|
if ((fd = open (device, O_RDONLY)) < 0) {
|
|
fprintf(stderr, "loop: can't delete device %s: %s\n",
|
|
device, strerror (errno));
|
|
return 1;
|
|
}
|
|
if (ioctl (fd, LOOP_CLR_FD, 0) < 0) {
|
|
#if 0
|
|
perror ("ioctl: LOOP_CLR_FD");
|
|
#endif
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
lomount (const char *spec, const char *node, const char *device, char **type,
|
|
int *flags, char **extra_opts, char **mount_opts)
|
|
{
|
|
char *opt,
|
|
*opteq;
|
|
int val;
|
|
char *encryption = NULL, *vfs = NULL;
|
|
int offset = 0, err;
|
|
char new_opts[1024];
|
|
|
|
for (opt = strtok (*extra_opts, ","); opt; opt = strtok (NULL, ",")) {
|
|
if ((opteq = strchr (opt, '='))) {
|
|
val = atoi (opteq + 1);
|
|
*opteq = '\0';
|
|
if (!strcmp (opt, "encryption"))
|
|
encryption = strdup(opteq + 1);
|
|
else if (!strcmp (opt, "vfs"))
|
|
vfs = strdup(opteq + 1);
|
|
else if (!strcmp (opt, "offset"))
|
|
offset = val;
|
|
else {
|
|
printf ("unknown loop mount parameter: "
|
|
"%s=%d (%s)\n", opt, val, opteq+1);
|
|
return 1;
|
|
}
|
|
} else {
|
|
printf ("unknown loop mount parameter: "
|
|
"%s\n", opt);
|
|
return 1;
|
|
}
|
|
}
|
|
err = set_loop (device, spec, offset, encryption);
|
|
sprintf(new_opts, "vfs=%s,offset=%d,encryption=%s",
|
|
*type = vfs ? vfs : FSTYPE_DEFAULT, offset,
|
|
encryption=crypt_type(encryption)<0?"none":encryption);
|
|
*extra_opts=strdup(new_opts);
|
|
return err;
|
|
}
|