#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>

#include "dpkg.h"
#include "memory.h"

// enlarge this if britney has issues parsing packages
// (e.g. very slow installability checks)
#define SIZEOFHASHMAP 16

/* #define DIAGNOSE 1 */

#define insert_packagenamelist(x,y) insert_l_packagenamelist(x,y,__LINE__)

static void free_dependency(dependency *dep);
static void free_package(dpkg_package *pkg);
static void free_collected_package(dpkg_collected_package *pkg);
static dpkg_paragraph *read_paragraph( FILE *f );
static dpkg_package *read_package( FILE *f );
static collpackagelist **get_matching_low(collpackagelist **addto, 
		                          dpkg_packages *pkgs, dependency *dep, int line);
static collpackagelist *get_matching(dpkg_packages *pkgs, deplist *depopts, int line);
deplist *read_dep_and(char *buf);
deplistlist *read_dep_andor(char *buf);
ownedpackagenamelist *read_packagenames(char *buf);
static dpkg_sources *read_sources_file(char *filename, int n_arches);
static dpkg_source *new_source(dpkg_sources *owner);
static dpkg_source *read_source(FILE *f, dpkg_sources *owner);
static deplist *read_deplist(char **buf, char sep, char end);
static dependency *read_dependency(char **buf, char *end);
static void add_virtualpackage(virtualpkgtbl *vpkgs, char *package, 
                               char *version, dpkg_collected_package *cpkg);
static void remove_virtualpackage(virtualpkgtbl *vpkgs, char *pkgname,
			          dpkg_collected_package *cpkg);
static char *read_packagename(char **buf, char *end);
static char *read_until_char(char **buf, char *end);
void add_package(dpkg_packages *pkgs, dpkg_package *pkg);
void remove_package(dpkg_packages *pkgs, dpkg_collected_package *pkg);
static dpkg_source_note *copy_source_note(dpkg_source_note *srcn);

#if 0
static inline void *bm(size_t s, int n) { void *res = block_malloc(s); fprintf(stderr, "ALLOCED: %d %p %lu\n", n, res, s); return res; }
static inline void bf(void *p, size_t s, int n) { block_free(p,s); fprintf(stderr, "FREED: %d %p %lu\n", n, p, s); }

#define block_malloc(s) bm(s,__LINE__)
#define block_free(p,s) bf(p,s,__LINE__)
#endif

#define block_malloc(s) block_malloc2(s, __LINE__)

static char *priorities[] = {
    "required",
    "important",
    "standard",
    "optional",
    "extra",
    NULL
};

static char *dependency_title[] = {
    "Pre-Depends", "Depends", "Recommends", "Suggests", NULL
};

static int dependency_counts[] = { 1, 1, 0, 0 };

char *dependency_relation_sym[] = {"*", "<<", "<=", "=", ">=", ">>"};

#define SMB_SIZE (1<<22)
struct stringmemblock {
	struct stringmemblock *next;
	size_t last;
	char mem[SMB_SIZE];
};
static struct stringmemblock *stringmemory = NULL;
static int stringmemorycount = 0;
static const unsigned long stringmemblocksizekib = (unsigned long) sizeof(struct stringmemblock) / 1024;

char *my_strdup(char *foo) {
	struct stringmemblock *which;
	size_t len;

	if (!foo) return NULL;

	len = strlen(foo) + 1;

	if (len > SMB_SIZE) return strdup(foo);

	for (which = stringmemory; which; which = which->next) {
		if (SMB_SIZE - which->last > len + 1) {
			break;
		}
	}
	if (!which) {
		which = malloc(sizeof(struct stringmemblock));
		if (!which) return NULL;
		MDEBUG1_ONLY(fprintf(stderr, 
			"ALLOC: string memblock %d (%lu KiB, %lu KiB total)\n", 
			stringmemorycount, stringmemblocksizekib,
                        (stringmemorycount+1) * stringmemblocksizekib));
		memset(which->mem, 0, SMB_SIZE);
		which->last = 0;
		which->next = stringmemory;
		stringmemory = which;
		stringmemorycount++;
	}
	strcpy(&which->mem[which->last], foo);
	foo = &which->mem[which->last];
	which->last += len;
	return foo;
}

char *my_rep_strdup(char *foo) {
    static char *repeats[1000] = {0};
    int i;

    for (i = 0; i < 1000; i++) {
	if (repeats[i] == NULL) {
	    DEBUG_ONLY(fprintf(stderr, "REPEAT NR %d\n", i+1); )
	    return repeats[i] = my_strdup(foo);
	}
	if (strcmp(repeats[i], foo) == 0) return repeats[i];
    }

    return my_strdup(foo);
}

/* DIE **/

static void die(char *orig_msg) {
        char *msg = my_strdup(orig_msg);
        if (*msg && msg[strlen(msg)-1] == ':') {
                msg[strlen(msg)-1] = '\0';
                perror(msg);
        } else {
                printf("%s\n", msg);
        }
        abort();
}

/*************************************************************************
 * Dpkg Control/Packages/etc Operations
 */

static dpkg_paragraph *read_paragraph( FILE *f ) {
    dpkg_paragraph *result;
    static int line_size = 0;
    static char *line = NULL;
    char *pch;
   
    dpkg_entry *c_entry = NULL;
    char *c_value = NULL;
   
    if (line == NULL) {
        line_size = 10;
	line = malloc(line_size);
	if (line == NULL) die("read_paragraph alloc 0:");
    }
 
    result = block_malloc( sizeof(dpkg_paragraph) );
    if (result == NULL) die("read_paragraph alloc 1:");
    
    result->n_entries = 0;
    result->entry = NULL;
    result->n_allocated = 0;
    
    while(fgets(line, line_size, f)) {
	while (!feof(f) && *line && line[strlen(line)-1] != '\n') {
	    line = realloc(line, line_size * 2);
	    if (!line) die("read_paragraph realloc:");
	    fgets(line + strlen(line), line_size, f);
	    line_size *= 2;
        }

	if (line[0] == '\n') break;
	
	if (isspace(line[0])) {
	    if (c_value == NULL)
		die("read_paragraph early spaces");

	    if (c_entry == NULL) {
		/* no need to bother */
	    } else {
	        /* extend the line */
	        c_value = realloc(c_value, strlen(c_value) + strlen(line) + 1);
	        if (c_value == NULL)
		    die("read_paragraph realloc c_value:");
	    
	        strcat(c_value, line);
	    }
	} else {
	    if (c_entry) {
		    c_entry->value = my_strdup(c_value);
		    c_value[0] = '\0';
		    free(c_value); 
		    c_value = NULL;
	    } else if (c_value) {
		    free(c_value);
		    c_value = NULL;
	    }
	    pch = strchr(line, ':');
	    if (pch == NULL) {
                fprintf(stderr, "the line was: \"%s\"\n", line);
		die("read_paragraph: no colon");
            }
	    
	    *pch = '\0';
	    while(isspace(*++pch));

	    if (strcmp(line, "Description") == 0) {
		c_value = strdup(pch);
		c_entry = NULL;
	    } else {
	        assert(result->n_entries <= result->n_allocated);
	        if (result->n_entries >= result->n_allocated) {
		    result->n_allocated += 10;
		    result->entry = realloc( result->entry,
					     sizeof(dpkg_entry)
					     * result->n_allocated);
		    if (result->entry == NULL)
		        die("read_paragraph realloc entry:");
	        }

	        c_entry = &result->entry[result->n_entries++];
	        c_entry->name = my_rep_strdup(line);
	        c_value = strdup(pch);
	    }
	}
    }

    if (c_entry) {
	c_entry->value = my_strdup(c_value);
	c_value[0] = '\0';
	free(c_value);
	c_value = NULL;
    }

    if (result->n_entries == 0) {
	if (result->entry) free(result->entry);
	block_free(result, sizeof(dpkg_paragraph));
	return NULL;
    } else {
        result->entry = realloc(result->entry, 
	    sizeof(result->entry[0]) * result->n_entries);
	result->n_allocated = result->n_entries;
    }

    return result;
}

static void write_paragraph(FILE *f, dpkg_paragraph *p) {
    int i;

    for (i = 0; i < p->n_entries; i++) {
	fprintf(f, "%s: %s", p->entry[i].name, p->entry[i].value);
    }
    fprintf(f, "\n");
}


static void free_paragraph(dpkg_paragraph *p) {
    int i;
    
    if (p == NULL) return;
    
    for (i = 0; i < p->n_entries; i++) {
	/* block_free(p->entry[i].name); */
	/* block_free(p->entry[i].value); */
    }
    free(p->entry);
    block_free(p, sizeof(dpkg_paragraph));
}

/*************************************************************************
 * Basic Package Operations
 */

static dpkg_package *new_package(void) {
    dpkg_package *result;
    
    result = block_malloc(sizeof(dpkg_package));
    if (result == NULL) die("new_package alloc:");
    
    result->package    = NULL;
    result->version    = NULL;

    result->priority   = 0;
    result->arch_all   = 0;
    
    result->source     = NULL;
    result->source_ver = NULL;
    
    result->depends[0] = NULL;
    result->depends[1] = NULL;
    result->depends[2] = NULL;
    result->depends[3] = NULL;
    
    result->conflicts  = NULL;
    
    result->provides   = NULL;
    result->details    = NULL;
    
    return result;
}

static dpkg_collected_package *new_collected_package(dpkg_package *pkg) {
    dpkg_collected_package *result;

    result = block_malloc(sizeof(dpkg_collected_package));
    if (result == NULL) die("new_collected_package alloc:");

    result->pkg = pkg;

    result->installed  = 0;
    result->conflicted = 0;

    result->installable = UNKNOWN;
    result->mayaffect = NULL;

    return result;
}

static void free_collected_package(dpkg_collected_package *cpkg) {
    if (cpkg == NULL) return;
    cpkg->pkg = NULL;
    free_packagenamelist(cpkg->mayaffect);
    cpkg->mayaffect = NULL;
    block_free(cpkg, sizeof(dpkg_collected_package));
}   

static void free_package(dpkg_package *pkg) {
    int i;
    if (pkg == NULL) return;
    
    /* block_free(pkg->package);
     * block_free(pkg->version);
     * block_free(pkg->source);
     * block_free(pkg->source_ver); */

    for (i = 0; i < 4; i++)
	free_deplistlist(pkg->depends[i]);

    free_deplist(pkg->conflicts);
    free_ownedpackagenamelist(pkg->provides);
    
    free_paragraph(pkg->details);
    
    block_free(pkg, sizeof(dpkg_package));
}

static dpkg_package *read_package( FILE *f ) {
    dpkg_package *result;
    dpkg_paragraph *para;
    dpkg_entry *e;
    int i;

    para = read_paragraph(f);
    if (para == NULL) return NULL;
    
    result = new_package();
    result->details = para;
    
    for (e = &para->entry[0]; e < &para->entry[para->n_entries]; e++) {
	if (strcasecmp("Package", e->name) == 0) {
	    result->package = my_strdup(e->value);
	    if (result->package == NULL)
		die("read_package my_strdup:");
	    result->package[strlen(result->package)-1] = '\0';
	}
	
	if (strcasecmp("Version", e->name) == 0) {
	    result->version = my_strdup(e->value);
	    if (result->version == NULL)
		die("read_package my_strdup:");
	    result->version[strlen(result->version)-1] = '\0';
	}
	
	if (strcasecmp("Priority", e->name) == 0) {
	    int i;
	    for (i = 0; priorities[i] != NULL; i++) {
		if (strcasecmp(priorities[i], e->value))
		    break;
	    }
	    result->priority = i;
	    if (priorities[i] == NULL) {
		die("read_package: unknown priority");
	    }
	}

	if (strcasecmp("Architecture", e->name) == 0) {
	    if (strncasecmp(e->value, "all", 3) == 0) {
		if (!e->value[3] || isspace(e->value[3])) {
	            result->arch_all = 1;
		}
	    }
	}
	
	for (i = 0; dependency_title[i] != NULL; i++) {
	    if (strcasecmp(dependency_title[i], e->name) == 0) {
		result->depends[i] = read_dep_andor(e->value);
	    }
	}
	
	if (strcasecmp("Conflicts", e->name) == 0)
	    result->conflicts = read_dep_and(e->value);
	
	if (strcasecmp("Provides", e->name) == 0)
	    result->provides = read_packagenames(e->value);
	
	if (strcasecmp("source", e->name) == 0) {
	    char *pch = e->value;
	    
	    assert(result->source == NULL);
	    assert(result->source_ver == NULL);
	    
	    result->source = my_strdup(read_packagename(&pch, "("));
	    if (result->source == NULL)
		die("read_package: bad source header");
	    
	    while(isspace(*pch)) pch++;
	    if (*pch == '(') {
		pch++;
		result->source_ver = my_strdup(read_until_char(&pch, ")"));
		if (result->source_ver == NULL)
		    die("read_package: bad source version");
		while(isspace(*pch)) pch++;
		if (*pch != ')')
		    die("read_package: unterminated ver");
	    }
	}
    }

    if (result->source == NULL) {
	assert(result->source_ver == NULL);
	result->source = my_strdup(result->package);
    }
    if (result->source_ver == NULL) {
	result->source_ver = my_strdup(result->version);
    }
    
    return result;
}

static void freesize(void *p, size_t s) { (void)s; free(p); }

LIST_IMPL(deplist, dependency*, free_dependency, block_malloc, block_free);
LIST_IMPL(deplistlist, deplist*, free_deplist, block_malloc, block_free);

LIST_IMPLX(packagenamelist, char*, KEEP(char*));

LIST_IMPL(ownedpackagenamelist, char*, KEEP(char*), block_malloc, block_free);
	/* ownedpackagenamelist stores the packagename in the string store */

static int packagecmp(dpkg_package *l, dpkg_package *r) {
    if (l->priority < r->priority) return -1;
    if (l->priority > r->priority) return +1;
    return strcmp(l->package, r->package);
}

/* container for owned pkgs */
LIST_IMPL(ownedpackagelist, dpkg_package *, free_package, 
		block_malloc, block_free);

/* container for existing pkgs */
LIST_IMPL(packagelist, dpkg_package *, KEEP(dpkg_package *), block_malloc, block_free);

LIST_IMPLX(collpackagelist, dpkg_collected_package *, 
	  KEEP(dpkg_collected_package *))
#define insert_collpackagelist(x,y) insert_l_collpackagelist(x,y,__LINE__)

/*************************************************************************
 * Operations on distributions (collections of packages)
 */

dpkg_packages *new_packages(char *arch) {
    dpkg_packages *result;

    result = block_malloc(sizeof(dpkg_packages));
    if (result == NULL) die("new_packages alloc:");
    
    result->arch = my_strdup(arch);
    result->packages = new_packagetbl();
    result->virtualpkgs = new_virtualpkgtbl();

    return result;
}

void add_package(dpkg_packages *pkgs, dpkg_package *pkg) 
{
    ownedpackagenamelist *v;
    dpkg_collected_package *cpkg;

    if (lookup_packagetbl(pkgs->packages, pkg->package) != NULL) 
	return;

    cpkg = new_collected_package(pkg);

    add_packagetbl(pkgs->packages, cpkg->pkg->package, cpkg);
	
    add_virtualpackage(pkgs->virtualpkgs, cpkg->pkg->package, 
		       cpkg->pkg->version, cpkg);
    for (v = cpkg->pkg->provides; v != NULL; v = v->next) {
	add_virtualpackage(pkgs->virtualpkgs, v->value, NULL, cpkg);
    }
}

void remove_package(dpkg_packages *pkgs, dpkg_collected_package *cpkg) {
    ownedpackagenamelist *v;
    packagenamelist *aff;
    dpkg_collected_package *p;

    for (aff = cpkg->mayaffect; aff != NULL; aff = aff->next) {
	p = lookup_packagetbl(pkgs->packages, aff->value);
	if (p == NULL) continue;
	p->installable = UNKNOWN;
    }

    p = remove_packagetbl(pkgs->packages, cpkg->pkg->package);
    if (p != cpkg) return;
	
    remove_virtualpackage(pkgs->virtualpkgs, cpkg->pkg->package, cpkg);
    for (v = cpkg->pkg->provides; v != NULL; v = v->next) {
	remove_virtualpackage(pkgs->virtualpkgs, v->value, cpkg);
    }

    free_collected_package(cpkg);
}

dpkg_packages *get_architecture(dpkg_sources *srcs, char *arch) {
    int i, arch_index;
    dpkg_packages *result;
    sourcetbl_iter srci;
    ownedpackagelist *p;
    
    arch_index = -1;
    for (i = 0; i < srcs->n_arches; i++) {
	if (strcmp(srcs->archname[i], arch) == 0) {
	    arch_index = i;
	    break;
	}
    }
    if (arch_index == -1) die("get_architecture: unknown arch");
    
    result = new_packages(arch);

    for (srci = first_sourcetbl(srcs->sources);
	 !done_sourcetbl(srci);
	 srci = next_sourcetbl(srci))
    {
	for (p = srci.v->packages[arch_index]; p != NULL; p = p->next) {
	    add_package(result, p->value);
	}
    }
    
    return result;
}

void free_packages(dpkg_packages *pkgs) {
    if (pkgs == NULL) return;
    /* block_free(pkgs->arch); */
    free_packagetbl(pkgs->packages);
    free_virtualpkgtbl(pkgs->virtualpkgs);
    block_free(pkgs, sizeof(dpkg_packages));
}


HASH_IMPL(packagetbl, char *, dpkg_collected_package *, SIZEOFHASHMAP, strhash, strcmp,
	  KEEP(char*),free_collected_package);
HASH_IMPL(virtualpkgtbl, char *, virtualpkg *, SIZEOFHASHMAP, strhash, strcmp,
	  KEEP(char*), free_virtualpkg);

/* dpkg_provision refers to memory allocated elsewhere */
LIST_IMPL(virtualpkg, dpkg_provision, KEEP(dpkg_provision), block_malloc, block_free);

static void remove_virtualpackage(virtualpkgtbl *vpkgs, char *pkgname,
			          dpkg_collected_package *cpkg)
{
    virtualpkg *list;
    virtualpkg **where;
    list = lookup_virtualpkgtbl(vpkgs, pkgname);
    assert(list != NULL);

    where = &list;
    while((*where)->value.pkg != cpkg) {
	where = &(*where)->next;
	assert(*where != NULL);
    }
    
    delete_virtualpkg(where);

    if (list == NULL) {
	remove_virtualpkgtbl(vpkgs, pkgname);
    } else {
	replace_virtualpkgtbl(vpkgs, pkgname, list);
    }
}

static void add_virtualpackage(virtualpkgtbl *vpkgs, char *package, 
                               char *version, dpkg_collected_package *cpkg)
{
    dpkg_provision value;
    virtualpkg *list, **addto;
    int shouldreplace;
   
    value.pkg = cpkg;
    value.version = version;
    
    list = lookup_virtualpkgtbl(vpkgs, package);
    shouldreplace = (list != NULL);

    addto = &list;
    while (*addto != NULL
	   && packagecmp(cpkg->pkg, (*addto)->value.pkg->pkg) >= 0) 
    {
	addto = &(*addto)->next;
    }
    insert_virtualpkg(addto, value);

    if (shouldreplace) {
	replace_virtualpkgtbl(vpkgs, package, list);
	/* old list is included in new list, so we don't need to free */
    } else {
	add_virtualpkgtbl(vpkgs, package, list);
    }
}

/*************************************************************************
 * Parsing Helper Functions
 */

ownedpackagenamelist *read_packagenames(char *buf) {
    ownedpackagenamelist *result = NULL;
    ownedpackagenamelist **addto = &result;

    DEBUG_ONLY( char *strend = buf + strlen(buf); )
    
    char *sub;
    
    while ((sub = my_strdup(read_packagename(&buf, ",")))) {
	insert_ownedpackagenamelist(addto, sub);
	addto = &(*addto)->next;
	
	while(isspace(*buf)) buf++;
	if (*buf == ',') {
	    buf++;
	    continue;
	}
	if (*buf == '\0') {
	    break;
	}
	
	die("read_packagenames no/bad seperator");
    }
    
    DEBUG_ONLY( assert(buf <= strend); )
    
    return result;
}

static char *read_until_char(char **buf, char *end) {
    static char *result = NULL;
    char *start;
    DEBUG_ONLY( char *strend = *buf + strlen(*buf); )
    int n;
    
    while(isspace(**buf)) (*buf)++;
    
    start = *buf;
    while (**buf && !isspace(**buf) && strchr(end, **buf) == NULL) {
	(*buf)++;
    }
    
    n = *buf - start;
    if (n == 0) return NULL;
    
    result = realloc(result, n + 1);
    if (result == NULL) die("read_until_char alloc:");
    
    strncpy(result, start, n);
    result[n] = '\0';
    
    while(isspace(**buf)) (*buf)++;
    
    DEBUG_ONLY( assert(*buf <= strend); )
    
    return result;
}

static char *read_packagename(char **buf, char *end) {
    return read_until_char(buf, end);
}

deplist *read_dep_and(char *buf) {
    return read_deplist(&buf, ',', '\0'); 
}

static deplist *read_deplist(char **buf, char sep, char end) {
    deplist *result = NULL;
    deplist **addto = &result;
    
    char separs[3] = { sep, end, '\0' };
    
    DEBUG_ONLY( char *strend = *buf + strlen(*buf); )
    
    dependency *sub;
    
    while ((sub = read_dependency(buf, separs))) {
	insert_deplist(addto, sub);
	addto = &(*addto)->next;
	
	while(isspace(**buf)) (*buf)++;
	if (**buf == sep) {
	    (*buf)++;
	    continue;
	}
	if (**buf == '\0' || **buf == end) {
	    break;
	}

	die("read_deplist no/bad seperator");
    }
    
    DEBUG_ONLY( assert(*buf <= strend); )
    
    return result;
}

deplistlist *read_dep_andor(char *buf) {
    deplistlist *result = NULL;
    deplistlist **addto = &result;
    
    deplist *sub;
    
    DEBUG_ONLY( char *strend = buf + strlen(buf); )
    
    while ((sub = read_deplist(&buf, '|', ','))) {
	insert_deplistlist(addto, sub);
	addto = &(*addto)->next;
	
	if (*buf == ',') buf++;
    }
    
    DEBUG_ONLY( assert(buf <= strend); )
    
    return result;
}

static dependency *read_dependency(char **buf, char *end) {
    dependency *dep;
    char *name;
    char newend[10];
    DEBUG_ONLY( char *strend = *buf + strlen(*buf); )
    
    assert(strlen(end) <= 8);
    newend[0] = '('; strcpy(newend + 1, end);
    
    name = my_strdup(read_until_char(buf, newend));
    if (name == NULL) return NULL;
    
    dep = block_malloc(sizeof(dependency));
    if (dep == NULL) die("read_dependency alloc 1:");
    
    dep->package = name;
    
    while(isspace(**buf)) (*buf)++;
    
    if (**buf != '(') {
	dep->op = dr_NOOP;
	dep->version = NULL;
    } else {
	(*buf)++;
	while(isspace(**buf)) (*buf)++;
	/* << , <= , = , >= , >> */
	if (**buf == '<') {
	    (*buf)++;
	    if (**buf == '<') {
		dep->op = dr_LT;
		(*buf)++;
	    } else if (**buf == '=') {
		dep->op = dr_LTEQ;
		(*buf)++;
	    } else {
		/* The forms `<' and `>' were used to mean earlier/later or 
		 * equal, rather than strictly earlier/later, so they should 
		 * not appear in new packages (though `dpkg' still supports 
		 * them).
		 */
		dep->op = dr_LTEQ;
	    }
	} else if (**buf == '>') {
	    (*buf)++;
	    if (**buf == '>') {
		dep->op = dr_GT;
		(*buf)++;
	    } else if (**buf == '=') {
		dep->op = dr_GTEQ;
		(*buf)++;
	    } else {
		dep->op = dr_GTEQ;
	    }
	} else if (**buf == '=') {
	    dep->op = dr_EQ;
	    (*buf)++;
	    if (**buf == '>') {
		dep->op = dr_GTEQ;
		(*buf)++;
	    } else if (**buf == '<') {
		dep->op = dr_LTEQ;
		(*buf)++;
	    }
	} else {
	    /* treat it as an implicit = :( */
	    dep->op = dr_EQ;
	    /* would prefer to: die("read_dependency unknown version op"); */
	}
	
	while (isspace(**buf)) (*buf)++;
	newend[0] = ')';
	dep->version = my_strdup(read_until_char(buf, newend));
	while (isspace(**buf)) (*buf)++;
	
	if (dep->version == NULL) die("read_dependency: no version");
	if (**buf != ')') die("read_dependency: unterminated version");
	(*buf)++;
    }
    
    DEBUG_ONLY( assert(*buf <= strend); )
    
    return dep;
}

static void free_dependency(dependency *dep) {
    if (dep == NULL) return;
    /* block_free(dep->package); */
    /* if (dep->version) block_free(dep->version); */
    block_free(dep, sizeof(dependency));
}

/*************************************************************************
 * Installability Checking
 */

static collpackagelist **get_matching_low(collpackagelist **addto, 
		                          dpkg_packages *pkgs, dependency *dep, int line)
{
    virtualpkg *vpkg;
    for (vpkg = lookup_virtualpkgtbl(pkgs->virtualpkgs, dep->package);
	 vpkg != NULL;
	 vpkg = vpkg->next)
    {
	int add;

	add = 0;
	if (dep->op == dr_NOOP) {
	    add = 1;
	} else if (vpkg->value.version != NULL) {
	    if (cmpversions(vpkg->value.version, dep->op, dep->version)) {
		add = 1;
	    }
	}

	if (add) {
	    insert_l_collpackagelist(addto, vpkg->value.pkg, line);
	    addto = &(*addto)->next;
	}
    }

    return addto;
}

static collpackagelist *get_matching(dpkg_packages *pkgs, deplist *depopts, int line) {
    collpackagelist *list = NULL;
    collpackagelist **addto = &list;
    
    for(; depopts != NULL; depopts = depopts->next) {
	addto = get_matching_low(addto, pkgs, depopts->value, line);
    }

    return list;
}

typedef struct instonelist instonelist;
struct instonelist {
    collpackagelist *curX;
    collpackagelist *instoneX;
    int expandedX;
    struct instonelist *nextX, *prevX, *cutoffX;
};

#define I1CUR(i1)      ((i1)->curX)
#define I1INSTONE(i1)  ((i1)->instoneX)
#define I1CUTOFF(i1)   ((i1)->cutoffX)
#define I1NEXT(i1)     ((i1)->nextX) /* can be modified ! */
#define I1PREV(i1)     ((i1)->prevX)
#define I1EXPANDED(i1) ((i1)->expandedX)

static instonelist *insert_instonelist(instonelist *where, collpackagelist *instone);
static void trim_instonelist_after(instonelist *first);
static void free_instonelist(instonelist *l);

static instonelist *insert_instonelist(instonelist *old, collpackagelist *instone)
{
    instonelist *n = block_malloc(sizeof(instonelist));
    if (n == NULL)
        die("insert_instonelist alloc:");

    n->curX = NULL;
    n->instoneX = instone;
    n->cutoffX = NULL;
    n->nextX = (old ? old->nextX : NULL);
    n->prevX = old;
    n->expandedX = 0;

    if (old) old->nextX = n;
    if (n->nextX) n->nextX->prevX = n;

    return n;
}

static void trim_instonelist_after(instonelist *first) {
    if (!first->nextX) return;
    first->nextX->prevX = NULL;
    free_instonelist(first->nextX);
    first->nextX = NULL;
}

static void free_instonelist(instonelist *l) {
    instonelist *p, *k;
    if (!l) return;
    for (p = l; p->nextX; p = p->nextX);
    do {
        k = p;
        p = k->prevX;
        free_collpackagelist(k->instoneX);
        block_free(k, sizeof(instonelist));
    } while (k != l);
}

static int caninstall(dpkg_packages *pkgs, dpkg_collected_package *cpkg) {
    collpackagelist *conflicts;
    collpackagelist *conf;
    int okay;

    if (cpkg->installed > 0) return 1;
    if (cpkg->conflicted > 0) return 0;

    conflicts = get_matching(pkgs, cpkg->pkg->conflicts, __LINE__);

    okay = 1;
    for (conf = conflicts; conf != NULL; conf = conf->next) {
	if (conf->value->installed > 0) {
	    okay = 0;
	    break;
	}
    }
    free_collpackagelist(conflicts);
    return okay;
}

static void install(dpkg_packages *pkgs, dpkg_collected_package *cpkg) {
    if (cpkg->installed == 0) {
	collpackagelist *conflicts = get_matching(pkgs, cpkg->pkg->conflicts, __LINE__);
	collpackagelist *conf;
	for (conf = conflicts; conf != NULL; conf = conf->next) {
	    if (conf->value == cpkg) continue;
	    assert(conf->value->installed == 0);
	    conf->value->conflicted++;
	}
	free_collpackagelist(conflicts);
    }
    assert(cpkg->conflicted == 0);
    cpkg->installed++;
}

static void uninstall(dpkg_packages *pkgs, dpkg_collected_package *cpkg) {
    assert(cpkg->installed > 0);
    assert(cpkg->conflicted == 0);
    cpkg->installed--;
    if (cpkg->installed == 0) {
	collpackagelist *conflicts = get_matching(pkgs, cpkg->pkg->conflicts, __LINE__);
	collpackagelist *conf;
	for (conf = conflicts; conf != NULL; conf = conf->next) {
	    if (conf->value == cpkg) continue;
	    assert(conf->value->installed == 0);
	    assert(conf->value->conflicted > 0);
	    conf->value->conflicted--;
	}
	free_collpackagelist(conflicts);
    }
}

satisfieddep *new_satisfieddep(void) {
	satisfieddep *sd = block_malloc(sizeof(satisfieddep));
	if (!sd) die("new_satisfieddep alloc:");
	return sd;
}

void free_satisfieddep(satisfieddep *sd) {
	if (!sd) return;
	free_packagelist(sd->pkgs);
	block_free(sd, sizeof(satisfieddep));
}

LIST_IMPL(satisfieddeplist, satisfieddep *, free_satisfieddep, block_malloc, block_free);

packagelist *collpkglist2pkglist(collpackagelist *l) {
	packagelist *r = NULL;
	packagelist **addto = &r;

	for (; l != NULL; l = l->next) {
		insert_packagelist(addto, l->value->pkg);
		addto = &(*addto)->next;
	}

	return r;
}

satisfieddeplist *checkunsatisfiabledeps(dpkg_packages *pkgs, 
					 deplistlist *deps) {
	satisfieddeplist *unsatisfiable = NULL;
	satisfieddeplist **addto = &unsatisfiable;
	satisfieddep *sd;
	collpackagelist *deppkgs;

	for (; deps != NULL; deps = deps->next) {
		/* deplist *dep; */
		/* for (dep = deps->value; dep != NULL; dep = dep->next) { */
			sd = new_satisfieddep();
			/* sd->dep = dep->value; */
			sd->depl = deps->value;

			deppkgs = NULL;
			/* get_matching_low(&deppkgs, pkgs, dep->value); */
			deppkgs = get_matching(pkgs, deps->value, __LINE__);
			sd->pkgs = collpkglist2pkglist(deppkgs);
			free_collpackagelist(deppkgs);

			insert_satisfieddeplist(addto, sd);
			addto = &(*addto)->next;
		/* } */
	}

	return unsatisfiable;
}

int checkinstallable2(dpkg_packages *pkgs, char *pkgname) {
    dpkg_collected_package *cpkg = lookup_packagetbl(pkgs->packages, pkgname);
    collpackagelist *cpl = NULL;

    if (cpkg == NULL) return 0;

    insert_collpackagelist(&cpl, cpkg);
    /* cpl gets freed in checkinstallable :-/ */
    return checkinstallable(pkgs, cpl);
}

static void debug_checkinstallable(FILE *out, instonelist *list, 
	instonelist *last, instonelist *pointer) 
{
    instonelist *l;
    fprintf(out, "Status:");

    /* codes:   | = multiple options here
     *          @ = no options can satisfy this dep
     *          + = dependencies that can be expanded have been
     *          * = nothing selected yet
     *          > = where pointer points
     *          ^ = the cut point for where we are
     */

    for (l = list; ; l = I1NEXT(l)) {
	fprintf(out, " ");
	if (l == pointer)           fprintf(out, ">");
	if (l == I1CUTOFF(pointer)) fprintf(out, "^");
	if (I1INSTONE(l) == NULL) {
	    fprintf(out, "@");
	} else {
	    if (I1INSTONE(l)->next != NULL) {
		fprintf(out, "|");
	    }
	    if (I1EXPANDED(l)) {
		fprintf(out, "+");
	    }
	    if (I1CUR(l) == NULL) {
	        fprintf(out, "*%s", I1INSTONE(l)->value->pkg->package);
	    } else {
		fprintf(out, "%s", I1CUR(l)->value->pkg->package);
	    }
	}
	if (l == last) break;
    }
    fprintf(out, " ###\n");
    fflush(out);
}    

int checkinstallable(dpkg_packages *pkgs, collpackagelist *instoneof) {
    /* We use pkg->installed, pkg->conflicted to note how many
     * times we've used this pkg to satisfy a dependency or installed
     * a package that conflicts with it.
     *    Thus: pkg->installed == 0, or pkg->conflicted == 0
     *
     * We assume these are okay initially, aren't being played with
     * concurrently elsewhere, and make sure they're still okay when
     * we return.
     */
   
    instonelist *list;
    instonelist *last;
    
    instonelist *pointer;

    unsigned long counter = 10000000;

    {
	collpackagelist *cpkg;
        for (cpkg = instoneof; cpkg; cpkg = cpkg->next) {
	    if (cpkg->value->installable == YES) {
		free_collpackagelist(instoneof);
		return 1;
	    }
	}
    }
    
    list = insert_instonelist(NULL, instoneof);

    last = list;
    pointer = list;
    
    while(--counter > 0 && pointer) {
	deplistlist *dep;
	dpkg_collected_package *instpkg; /* convenient alias */
	int i;

#ifndef NDEBUG
	{
	    instonelist *p;
	    for (p = list; p != pointer; p = I1NEXT(p)) {
		assert(p != NULL);
		assert(I1CUR(p) != NULL);
		assert(I1CUR(p)->value != NULL);
		assert(I1CUR(p)->value->installed > 0);
		assert(I1CUR(p)->value->conflicted == 0);
	    }
	    if (I1NEXT(pointer) == NULL) {
		assert(pointer == last);
	    } else {
		for (p = I1NEXT(pointer); p; p = I1NEXT(p)) {
		    if (I1NEXT(p) == NULL) {
 			assert(p == last);
		    }
		    assert(I1CUR(p) == NULL);
		}
	    }
	}
#endif

#ifdef DIAGNOSE
        debug_checkinstallable(stdout, list, last, pointer);
#endif

	if (I1CUR(pointer) == NULL) {
	    I1CUR(pointer) = I1INSTONE(pointer);
	    /* try to choose an already installed package if there is one */
	    while (I1CUR(pointer) != NULL) {
		if (I1CUR(pointer)->value->installed != 0) {
		    break;
		}
		I1CUR(pointer) = I1CUR(pointer)->next;
	    }
	    if (I1CUR(pointer) == NULL) {
		I1CUR(pointer) = I1INSTONE(pointer);
	    }
	    assert(I1CUR(pointer) || !I1INSTONE(pointer));

	    I1CUTOFF(pointer) = last;
	} else {
	    uninstall(pkgs, I1CUR(pointer)->value);
	    trim_instonelist_after(I1CUTOFF(pointer));
	    last = I1CUTOFF(pointer);
	    
	    if (I1CUR(pointer)->value->installed > 0) {
		/* this dependency isn't the issue -- even doing
		 * nothing to satisfy it (ie, using an already
		 * installed package) doesn't do any good. So give up.  
		 */
		I1CUR(pointer) = NULL;
	    } else {
		I1CUR(pointer) = I1CUR(pointer)->next;
	    }
	}
	
	while(I1CUR(pointer) && !caninstall(pkgs, I1CUR(pointer)->value)) {
	    I1CUR(pointer) = I1CUR(pointer)->next;
	}
	
	if (I1CUR(pointer) == NULL) {
	    if (I1PREV(pointer) == NULL) break;
	    pointer = I1PREV(pointer);
	    continue;
	}
	
	instpkg = I1CUR(pointer)->value;
	
	install(pkgs, instpkg);
	
	assert(instpkg->installed > 0);
	if (instpkg->installed == 1) {
            /* if it's been installed exactly once, then this must've been
	     * the first time it was touched, so we need to look at the 
	     * dependencies. If it's the second or later, then we don't care 
	     * about them.
	     */

	    /* if any of the deps can't be satisfied, don't move on */
	    int bother = 1;

	    int expanded = I1EXPANDED(pointer);

	    for (i = 0; i < 4; i++) {
		if (!dependency_counts[i]) continue;
		for (dep = instpkg->pkg->depends[i];
		     dep != NULL; dep = dep->next)
		{
		    collpackagelist *thisdep = get_matching(pkgs, dep->value, __LINE__);

		    if (thisdep == NULL)  {
			bother = 0;

		    } else if (thisdep != NULL && thisdep->next == NULL) {
			collpackagelist *x;

			/* if there's only one way of fulfilling this dep,
			 * do it "ASAP"
			 */

			/* optimisation: if thisdep == foo, but the parent
			 * was foo|bar, then we already know "foo" is not going
			 * to work in this combination, and we can skip it.
			 *
			 * This deals with cases like X deps: Y|bar, bar deps: Y
			 * where bar is a virtual package; cf xlibs
			 */
			for (x = I1INSTONE(pointer); x != I1CUR(pointer); x = x->next) {
			    if (x->value == thisdep->value) {
			        bother = 0;
			        break;
			    }
			}

		        if (I1INSTONE(pointer)->next == NULL) {
		            /* the parent of this entry essentially depends 
			     * on this too, so we'll get it out of the way 
			     * ASAP, to reduce the degree of exponentiation 
			     * in bad cases.
			     *
			     * _However_ we only want to do this _once_ for
			     * any particular node.
			     */
			    if (expanded) {
				/* thisdep isn't used! */
				free_collpackagelist(thisdep);
			    } else {
				insert_instonelist(pointer, thisdep);
	    			I1EXPANDED(pointer) = 1;
			    }
			} else {
			    insert_instonelist(I1CUTOFF(pointer), thisdep);
			}
			if (I1NEXT(last)) last = I1NEXT(last);
			assert(!I1NEXT(last));

		    } else {
			/* otherwise it's a multi possibility dep, so do it
			 * at the end
			 */

		        last = insert_instonelist(last, thisdep);
		    }
		}
	    }
	    if (!bother) {
		/* stay where we are, and try the next possibility */
		continue;
	    }
	}
	
	pointer = I1NEXT(pointer);
    }

    if (counter == 0) {
	fprintf(stderr, "AIEEE: counter overflow:");
	assert(pointer != NULL);
	if (I1CUR(pointer) == NULL || I1CUR(pointer)->value == NULL) {
	    /* we're not guaranteed that pointer will make sense here */
	    pointer = I1PREV(pointer);
	}
	for (; pointer != NULL; pointer = I1PREV(pointer)) {
	    if (I1CUR(pointer) == NULL) {
		/* should only happen at pointer, so not here */
		fprintf(stderr, " >> eep, no packages at pointer <<");
		continue;
	    }
	    if (I1CUR(pointer)->value == NULL) {
		/* should never happen */
		fprintf(stderr, " >> eep, no package selected <<");
		continue;
	    }
	    fprintf(stderr, " %s%s", 
		(I1INSTONE(pointer)->next == NULL ? "" : "|"),
		I1CUR(pointer)->value->pkg->package);
	    uninstall(pkgs, I1CUR(pointer)->value);
	}	
	fprintf(stderr, ".\n");
	free_instonelist(list);
	return 0;
    }

    if (pointer == NULL) {
	dpkg_collected_package *cpkg = I1CUR(list)->value;
	assert(cpkg->installable != YES);
	cpkg->installable = YES;
	for (pointer = last; pointer != NULL; pointer = I1PREV(pointer)) {
	    if (I1CUR(pointer)->value->installed == 1) {
		packagenamelist **p = &I1CUR(pointer)->value->mayaffect;
#if 0
		while ( *p && (*p)->value < cpkg->pkg->package ) {
		    p = &(*p)->next;
		}
                if (*p == NULL || (*p)->value > cpkg->pkg->package)
#endif
		{
		    insert_packagenamelist(p, cpkg->pkg->package);
		}
	    }
	    uninstall(pkgs, I1CUR(pointer)->value);
	}
	free_instonelist(list);
	return 1;
    } else {
	assert(I1CUR(list) == NULL);
	free_instonelist(list);
	return 0;
    }
}

/******************/

HASH_IMPL(sourcetbl, char *, dpkg_source *, SIZEOFHASHMAP, strhash, strcmp,
	  KEEP(char*), free_source);

static dpkg_sources *read_sources_file(char *filename, int n_arches) {
    FILE *f; 
    dpkg_sources *result;
    dpkg_source *src;
    int i;

    f = fopen(filename, "r");
    if (f == NULL && errno != ENOENT) {
	die("read_sources_file: couldn't open file:");
    }

    result = block_malloc(sizeof(dpkg_sources));
    if (result == NULL) die("read_sources_file alloc 1:");

    result->n_arches = n_arches;
    result->archname = block_malloc(sizeof(char*) * n_arches);
    if (result->archname == NULL) die("read_sources_file alloc 2:");
    for (i = 0; i < n_arches; i++) result->archname[i] = NULL;
    result->unclaimedpackages = block_malloc(sizeof(ownedpackagelist*) 
					     * n_arches);
    if (result->unclaimedpackages == NULL) die("read_sources_file alloc 3:");
    for (i = 0; i < n_arches; i++) result->unclaimedpackages[i] = NULL;

    result->sources = new_sourcetbl();

    if (f != NULL) {
        while ((src = read_source(f, result))) {
	    dpkg_source *old = lookup_sourcetbl(result->sources, src->package);
	    if (old == NULL) {
	        add_sourcetbl(result->sources, src->package, src);
            } else {
                if (versioncmp(old->version, src->version) || 1) {
                    int i;
		    old = replace_sourcetbl(result->sources, src->package, src);
                    for (i = 0; i < old->owner->n_arches; i++) {
	                assert(old->packages[i] == NULL);
                    }
		    free_source(old);
		} else {
                    int i;
                    for (i = 0; i < src->owner->n_arches; i++) {
	                assert(src->packages[i] == NULL);
                    }
		    free_source(src);
		}
	    }
        }
        fclose(f);
    }
    
    return result;    
}

void free_sources(dpkg_sources *s) {
    int i;
    if (s == NULL) return;
    free_sourcetbl(s->sources);
    for (i = 0; i < s->n_arches; i++) {
	/* block_free(s->archname[i]); */
	free_ownedpackagelist(s->unclaimedpackages[i]);
    }
    block_free(s->archname, s->n_arches * sizeof(char*));
    block_free(s->unclaimedpackages, s->n_arches * sizeof(ownedpackagelist*));
    block_free(s, sizeof(dpkg_sources));
}

static dpkg_source *new_source(dpkg_sources *owner) {
    dpkg_source *result;
    int i;
    
    result = block_malloc(sizeof(dpkg_source));
    if (result == NULL) die("new_source alloc 1:");
    
    result->package = NULL;
    result->version = NULL;
    result->details = NULL;
    result->fake = 0;

    result->owner = owner;
    result->packages = block_malloc(sizeof(packagelist*) * owner->n_arches);
    if (result->packages == NULL) die("new_source alloc 2:");
    for (i = 0; i < owner->n_arches; i++) {
	result->packages[i] = NULL;
    }

    return result;
}

static dpkg_source *read_source(FILE *f, dpkg_sources *owner) {
    dpkg_source *result;
    dpkg_paragraph *para;
    dpkg_entry *e;

    para = read_paragraph(f);
    if (para == NULL) return NULL;
    
    result = new_source(owner);
    result->details = para;
    
    for (e = &para->entry[0]; e < &para->entry[para->n_entries]; e++) {
	if (strcmp("Package", e->name) == 0) {
	    result->package = my_strdup(e->value);
	    if (result->package == NULL)
		die("read_source strdup:");
	    result->package[strlen(result->package)-1] = '\0';
	}
	
	if (strcmp("Version", e->name) == 0) {
	    result->version = my_strdup(e->value);
	    if (result->version == NULL)
		die("read_source strdup:");
	    result->version[strlen(result->version)-1] = '\0';
	}
    }

    return result;
}

void free_source(dpkg_source *s) {
    int i;
    if (s == NULL) return;
    assert(s->owner != NULL); /* shouldn't have allocated it */
    /* block_free(s->package); */
    /* block_free(s->version); */
    free_paragraph(s->details);
    for (i = 0; i < s->owner->n_arches; i++) {
	free_ownedpackagelist(s->packages[i]);
    }
    block_free(s->packages, s->owner->n_arches * sizeof(ownedpackagelist*));
    block_free(s, sizeof(dpkg_source));
}

/******************************/

dpkg_sources *read_directory(char *dir, int n_arches, char *archname[]) {
    char buf[1000];
    dpkg_sources *srcs;
    int i;
    
    snprintf(buf, 1000, "%s/Sources", dir);
    srcs = read_sources_file(buf, n_arches);

    for (i = 0; i < n_arches; i++) {
	FILE *f;
	dpkg_package *pkg;

	srcs->archname[i] = my_strdup(archname[i]);

	snprintf(buf, 1000, "%s/Packages_%s", dir, archname[i]);
	f = fopen(buf, "r");
	if (f == NULL && errno != ENOENT) die("load_dirctory fopen:");
        if (f != NULL) {
	    while ((pkg = read_package(f))) {
	        dpkg_source *src = lookup_sourcetbl(srcs->sources, pkg->source);
	        if (src == NULL) {
		    src = new_source(srcs);
		    src->fake = 1;
		    src->package = my_strdup(pkg->source);
		    src->version = my_strdup(pkg->source_ver);
		    add_sourcetbl(srcs->sources, src->package, src);
		} 
                insert_ownedpackagelist(&src->packages[i], pkg);
	    }
	    fclose(f);
	}
    }	

    return srcs;
}

void write_directory(char *dir, dpkg_sources *srcs) {
    FILE *src;
    FILE *archfile[100];
    char buf[1000];
    int i;
    sourcetbl_iter srciter;

    snprintf(buf, 1000, "%s/Sources", dir);
    src = fopen(buf, "w");
    if (!src) die("write_directory: Couldn't open Sources file for output");

    for (i = 0; i < srcs->n_arches; i++) {
	snprintf(buf, 1000, "%s/Packages_%s", dir, srcs->archname[i]);
	archfile[i] = fopen(buf, "w");
    }

    for (srciter = first_sourcetbl(srcs->sources);
	 !done_sourcetbl(srciter);
	 srciter = next_sourcetbl(srciter))
    {
	ownedpackagelist *p;
	int i;

	if (!srciter.v->fake) 
		write_paragraph(src, srciter.v->details);
	
	for (i = 0; i < srcs->n_arches; i++) {
	    for (p = srciter.v->packages[i]; p != NULL; p = p->next) {
		write_paragraph(archfile[i], p->value->details);
	    }
	}
    }
    
    fclose(src);
    for (i = 0; i < srcs->n_arches; i++) {
	fclose(archfile[i]);
    }
}

/*********************/

HASH_IMPL(sourcenotetbl, char *, dpkg_source_note *, SIZEOFHASHMAP, strhash, strcmp,
	  KEEP(char*), free_source_note);

dpkg_source_note *new_source_note(dpkg_source *src, int n_arches) {
    dpkg_source_note *result = block_malloc(sizeof(dpkg_source_note));
    int i;

    if (result == NULL) die("new_source_note alloc 1:");    
    result->source = src;
    result->n_arches = n_arches;
    result->binaries = block_malloc(n_arches * sizeof(packagelist*));
    if (result->binaries == NULL) die("new_source_note alloc 2:");
    for (i = 0; i < n_arches; i++) {
	result->binaries[i] = NULL;
    }
    return result;
} 

void free_source_note(dpkg_source_note *srcn) {
    int i;
    
    if (srcn == NULL) return;

    if (srcn->binaries != NULL) {
	for (i = 0; i < srcn->n_arches; i++) {
	    free_packagelist(srcn->binaries[i]);
	}
	block_free(srcn->binaries, sizeof(packagelist*) * srcn->n_arches);
    }
    block_free(srcn, sizeof(dpkg_source_note));
}    

#ifdef DEBUG
static int is_sources_note(dpkg_sources_note *srcsn) {
    int i;

    assert(srcsn != NULL);
    assert(srcsn->magic == 0xa1eebabe);
    assert(srcsn->pkgs != NULL);
    for (i = 0; i < srcsn->n_arches; i++) {
        assert(srcsn->pkgs[i] != NULL && srcsn->archname[i] != NULL);
        assert(strcmp(srcsn->archname[i], srcsn->pkgs[i]->arch) == 0);
    }

    return 1;
}
#endif

dpkg_sources_note *new_sources_note(int n_arches, char **archname) {
    dpkg_sources_note *result = block_malloc(sizeof(dpkg_sources_note));
    int i;

    if (result == NULL) die("new_sources_note alloc 1:");
    result->magic = 0xA1EEBABE;
    result->sources = new_sourcenotetbl();
    result->pkgs = block_malloc(n_arches * sizeof(dpkg_packages*));
    if (result->pkgs == NULL) die("new_sources_note alloc 2:");
    result->archname = block_malloc(n_arches * sizeof(char*));
    if (result->archname == NULL) die("new_sources_note alloc 3:");

    result->n_arches = n_arches;
    for (i = 0; i < n_arches; i++) {
	result->archname[i] = my_strdup(archname[i]);
	result->pkgs[i] = new_packages(result->archname[i]);
    }
    result->undo = NULL;
    return result;
}

void free_sources_note(dpkg_sources_note *srcsn) {
    int i;
    if (srcsn == NULL) return;
    assert(is_sources_note(srcsn));
    srcsn->magic = 0xBABEA1EE;
    free_sourcenotetbl(srcsn->sources);
    for (i = 0; i < srcsn->n_arches; i++) {
	free_packages(srcsn->pkgs[i]);
	/* block_free(srcsn->archname[i]); */
    } 
    block_free(srcsn->pkgs, sizeof(dpkg_packages*) * srcsn->n_arches);
    block_free(srcsn->archname, sizeof(char*) * srcsn->n_arches);
    free_source_note_listlist(srcsn->undo);
    block_free(srcsn, sizeof(dpkg_sources_note));
}

static void new_op(dpkg_sources_note *srcsn) {
    assert(is_sources_note(srcsn));
    insert_source_note_listlist(&srcsn->undo, NULL);
}
static void save_source_note(dpkg_sources_note *srcsn, dpkg_source_note *srcn) {
    source_note_list **where;
    assert(is_sources_note(srcsn));
    assert(srcsn->undo != NULL);

    for (where = &srcsn->undo->value; 
	 *where != NULL;
	 where = &(*where)->next) 
    {
        if ((*where)->value->source == srcn->source) 
	    return; 	/* already saved */
    }

    insert_source_note_list(where, copy_source_note(srcn));
}
static void save_empty_source_note(dpkg_sources_note *srcsn, dpkg_source *src) {
    dpkg_source_note *srcn;
    source_note_list **where;

    for (where = &srcsn->undo->value; 
	 *where != NULL; 
	 where = &(*where)->next)
    {
        if ((*where)->value->source == src) 
	    return; 	/* already saved */
    }

    srcn = block_malloc(sizeof(dpkg_source_note));
    if (srcn == NULL) die("save_empty_source_note alloc:");
    assert(is_sources_note(srcsn));

    srcn->source = src;
    srcn->n_arches = 0;
    srcn->binaries = NULL;

    insert_source_note_list(where, srcn);
}

typedef enum { DO_ARCHALL = 0, SKIP_ARCHALL = 1 } do_this;
static void remove_binaries_by_arch(dpkg_sources_note *srcsn,
				    dpkg_source_note *srcn, int archnum,
				    do_this arch_all) 
{
    packagelist *p;
    packagelist *leftovers = NULL, **addto = &leftovers;
    assert(is_sources_note(srcsn));

    assert(arch_all == SKIP_ARCHALL || NULL == lookup_sourcenotetbl(srcsn->sources,srcn->source->package));
	/* if we're removing the entire binary, we should already have
	 * removed the source. if we're removing just the binaries on this
	 * arch (not arch:all) then we may be keeping the source
	 *
	 * really a logical XOR, I think. we don't rely on this assertion
	 * here 
	 */

    for (p = srcn->binaries[archnum]; p != NULL; p = p->next) {
	dpkg_collected_package *cpkg;
	if (arch_all == SKIP_ARCHALL && p->value->arch_all) {
		insert_packagelist(addto, p->value);
		addto = &(*addto)->next;
		continue;
	}
	cpkg = lookup_packagetbl(srcsn->pkgs[archnum]->packages,
				 p->value->package);
	remove_package(srcsn->pkgs[archnum], cpkg);
    }
    free_packagelist(srcn->binaries[archnum]);
    srcn->binaries[archnum] = leftovers;
}

typedef enum { NOTUNDOABLE = 0, UNDOABLE = 1 } undoable;
static void add_binaries_by_arch(dpkg_sources_note *srcsn,
				 dpkg_source_note *srcn, dpkg_source *src,
				 int archnum, undoable undoop, do_this arch_all) 
{
    ownedpackagelist *p;
    const char *archname = srcsn->archname[archnum];
    int origarchnum = -1;
    int i;

    assert(is_sources_note(srcsn));
    assert(srcn == lookup_sourcenotetbl(srcsn->sources,srcn->source->package));
    for (i = 0; i < src->owner->n_arches; i++) {
	if (strcmp(archname, src->owner->archname[i]) == 0) {
	    origarchnum = i;
	    break;
	}
    }
    if (origarchnum == -1) return; /* nothing to add, no biggie */

    for (p = src->packages[origarchnum]; p != NULL; p = p->next) {
	dpkg_collected_package *cpkg;

	if (arch_all == SKIP_ARCHALL && p->value->arch_all) continue;

	if ((cpkg = lookup_packagetbl(srcsn->pkgs[archnum]->packages, 
				      p->value->package)))
        {
	    dpkg_source_note *srcnB;
	    packagelist **p;

	    if (!undoop) {
		printf("conflict w/o undo: binary %s, owned by %s, replaced by %s\n", cpkg->pkg->package, cpkg->pkg->source, src->package);
                fflush(stdout);
            }
	    srcnB = lookup_sourcenotetbl(srcsn->sources, cpkg->pkg->source);
            assert(srcnB != NULL);
                
            for (p = &srcnB->binaries[archnum]; *p != NULL; p = &(*p)->next) {
                if ((*p)->value == cpkg->pkg) break;
            }
            assert(*p != NULL); /* binary should be from source */

	    assert(undoop);
            save_source_note(srcsn, srcnB);
	    remove_package(srcsn->pkgs[archnum], cpkg);
            remove_packagelist(p);
	}

	add_package(srcsn->pkgs[archnum], p->value);
	insert_packagelist(&srcn->binaries[archnum], p->value);
    }
}    

void upgrade_source(dpkg_sources_note *srcsn, dpkg_source *src) {
    dpkg_source_note *srcn;
    int i;
   
    new_op(srcsn);
 
    assert(is_sources_note(srcsn));
    /* first, find the old source, if it exists */
    srcn = remove_sourcenotetbl(srcsn->sources, src->package);
    if (srcn != NULL) {
        save_source_note(srcsn, srcn);
	for (i = 0; i < srcn->n_arches; i++) {
	    remove_binaries_by_arch(srcsn, srcn, i, DO_ARCHALL);
	}
	free_source_note(srcn);
    } else {
        save_empty_source_note(srcsn, src);
    }
    
    /* then add the new one */    
    srcn = new_source_note(src, srcsn->n_arches);   
    add_sourcenotetbl(srcsn->sources, src->package, srcn);
    for (i = 0; i < srcsn->n_arches; i++) {
	add_binaries_by_arch(srcsn, srcn, src, i, UNDOABLE, DO_ARCHALL);
    }
    assert(is_sources_note(srcsn));
}

void upgrade_arch(dpkg_sources_note *srcsn, dpkg_source *src, char *arch) {
    dpkg_source_note *srcn;
    int archnum = -1;
    int i;

    assert(is_sources_note(srcsn));
    /* first, find the old source */
    srcn = lookup_sourcenotetbl(srcsn->sources, src->package);

    assert(srcn != NULL);
    new_op(srcsn);
    save_source_note(srcsn, srcn);

    /* then lookup the archnum */
    for (i = 0; i < srcsn->n_arches; i++) {
	if (strcmp(arch, srcsn->archname[i]) == 0) {
	    archnum = i;
	    break;
	}
    }
    if (archnum == -1) die("upgrade_arch: unknown arch");
    
    /* then remove the old stuff and add the new */    
    remove_binaries_by_arch(srcsn, srcn, archnum, SKIP_ARCHALL);
    add_binaries_by_arch(srcsn, srcn, src, archnum, UNDOABLE, SKIP_ARCHALL);
    assert(is_sources_note(srcsn));
}

void remove_source(dpkg_sources_note *srcsn, char *name) {
    dpkg_source_note *srcn;
    int i;

    assert(is_sources_note(srcsn));
    srcn = remove_sourcenotetbl(srcsn->sources, name);
    assert(srcn != NULL);

    new_op(srcsn);
    save_source_note(srcsn, srcn);
    for (i = 0; i < srcn->n_arches; i++) {
        remove_binaries_by_arch(srcsn, srcn, i, DO_ARCHALL);
    }
    free_source_note(srcn);
    assert(is_sources_note(srcsn));
}

int can_undo(dpkg_sources_note *srcsn) {
    assert(is_sources_note(srcsn));
    return srcsn->undo != NULL;
}

void undo_change(dpkg_sources_note *srcsn) {
    dpkg_source_note *srcnO, *srcnC; /* old, current */
    source_note_list *srcnl;
    int i;

    assert(is_sources_note(srcsn));
    assert(can_undo(srcsn));

    srcnl = remove_source_note_listlist(&srcsn->undo);

    while(srcnl) {
        srcnO = remove_source_note_list(&srcnl);
        assert(srcnO != NULL); /* can_undo() implies this is true... */
	
        srcnC = remove_sourcenotetbl(srcsn->sources, srcnO->source->package);
        if (srcnC != NULL) {
	    for (i = 0; i < srcnC->n_arches; i++) {
	        remove_binaries_by_arch(srcsn, srcnC, i, DO_ARCHALL);
	    }
	    free_source_note(srcnC);
            assert(!lookup_sourcenotetbl(srcsn->sources, 
					 srcnO->source->package));
        }

        if (srcnO->binaries == NULL) {
            /* no original source */
            assert(srcnC != NULL); /* some sort of no-op? freaky. */
	    free_source_note(srcnO);
        } else {
            packagelist *p;
            /* original source */
            add_sourcenotetbl(srcsn->sources, srcnO->source->package, srcnO);
            for (i = 0; i < srcsn->n_arches; i++) {
                for (p = srcnO->binaries[i]; p != NULL; p = p->next) {
		    add_package(srcsn->pkgs[i], p->value);
                }
            }
        }
    }
}

LIST_IMPL(source_note_list, dpkg_source_note *, free_source_note, 
          block_malloc, block_free);
LIST_IMPL(source_note_listlist, source_note_list *, free_source_note_list, 
          block_malloc, block_free);

void commit_changes(dpkg_sources_note *srcsn) {
    assert(is_sources_note(srcsn));
    free_source_note_listlist(srcsn->undo);
    srcsn->undo = NULL;
}

dpkg_source_note *copy_source_note(dpkg_source_note *srcn) {
    dpkg_source_note *srcn2;
    packagelist *src, **dest;
    int i;

    assert(srcn->binaries != NULL);

    srcn2 = block_malloc(sizeof(dpkg_source_note));
    if (srcn2 == NULL) die("copy_source_note alloc:");

    srcn2->source = srcn->source;
    srcn2->n_arches = srcn->n_arches;
    srcn2->binaries = block_malloc(sizeof(packagenamelist*) * srcn2->n_arches);
    if (srcn2->binaries == NULL) die("copy_source_note alloc:");

    for (i = 0; i < srcn2->n_arches; i++) {
        dest = &(srcn2->binaries[i]);
        *dest = NULL;
        for (src = srcn->binaries[i]; src; src = src->next) {
            insert_packagelist(dest, src->value);
            dest = &((*dest)->next);
        }
    }

    return srcn2;
}

void write_notes(char *dir, dpkg_sources_note *srcsn) {
    FILE *src;
    FILE *archfile[100];
    char buf[1000];
    int i;
    sourcenotetbl_iter srciter;

    assert(is_sources_note(srcsn));
    snprintf(buf, 1000, "%s/Sources", dir);
    src = fopen(buf, "w");
    for (i = 0; i < srcsn->n_arches; i++) {
	snprintf(buf, 1000, "%s/Packages_%s", dir, srcsn->archname[i]);
	archfile[i] = fopen(buf, "w");
    }

    for (srciter = first_sourcenotetbl(srcsn->sources);
	 !done_sourcenotetbl(srciter);
	 srciter = next_sourcenotetbl(srciter))
    {
	packagelist *p;
	int i;

	if (!srciter.v->source->fake)
		write_paragraph(src, srciter.v->source->details);
	
	for (i = 0; i < srcsn->n_arches; i++) {
	    for (p = srciter.v->binaries[i]; p != NULL; p = p->next) {
		write_paragraph(archfile[i], p->value->details);
	    }
	}
    }
    
    fclose(src);
    for (i = 0; i < srcsn->n_arches; i++) {
	fclose(archfile[i]);
    }
}