[linux.git] / scripts / mod / sumversion.c

#include <netinet/in.h>
#ifdef __sun__
#include <inttypes.h>
#else
#include <stdint.h>
#endif
#include <ctype.h>
#include <errno.h>
#include <string.h>
#include "modpost.h"

/*
 * Stolen form Cryptographic API.
 *
 * MD4 Message Digest Algorithm (RFC1320).
 *
 * Implementation derived from Andrew Tridgell and Steve French's
 * CIFS MD4 implementation, and the cryptoapi implementation
 * originally based on the public domain implementation written
 * by Colin Plumb in 1993.
 *
 * Copyright (c) Andrew Tridgell 1997-1998.
 * Modified by Steve French ([email protected]) 2002
 * Copyright (c) Cryptoapi developers.
 * Copyright (c) 2002 David S. Miller ([email protected])
 * Copyright (c) 2002 James Morris <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 */
#define MD4_DIGEST_SIZE		16
#define MD4_HMAC_BLOCK_SIZE	64
#define MD4_BLOCK_WORDS		16
#define MD4_HASH_WORDS		4

struct md4_ctx {
	uint32_t hash[MD4_HASH_WORDS];
	uint32_t block[MD4_BLOCK_WORDS];
	uint64_t byte_count;
};

static inline uint32_t lshift(uint32_t x, unsigned int s)
{
	x &= 0xFFFFFFFF;
	return ((x << s) & 0xFFFFFFFF) | (x >> (32 - s));
}

static inline uint32_t F(uint32_t x, uint32_t y, uint32_t z)
{
	return (x & y) | ((~x) & z);
}

static inline uint32_t G(uint32_t x, uint32_t y, uint32_t z)
{
	return (x & y) | (x & z) | (y & z);
}

static inline uint32_t H(uint32_t x, uint32_t y, uint32_t z)
{
	return x ^ y ^ z;
}

#define ROUND1(a,b,c,d,k,s) (a = lshift(a + F(b,c,d) + k, s))
#define ROUND2(a,b,c,d,k,s) (a = lshift(a + G(b,c,d) + k + (uint32_t)0x5A827999,s))
#define ROUND3(a,b,c,d,k,s) (a = lshift(a + H(b,c,d) + k + (uint32_t)0x6ED9EBA1,s))

/* XXX: this stuff can be optimized */
static inline void le32_to_cpu_array(uint32_t *buf, unsigned int words)
{
	while (words--) {
		*buf = ntohl(*buf);
		buf++;
	}
}

static inline void cpu_to_le32_array(uint32_t *buf, unsigned int words)
{
	while (words--) {
		*buf = htonl(*buf);
		buf++;
	}
}

static void md4_transform(uint32_t *hash, uint32_t const *in)
{
	uint32_t a, b, c, d;

	a = hash[0];
	b = hash[1];
	c = hash[2];
	d = hash[3];

	ROUND1(a, b, c, d, in[0], 3);
	ROUND1(d, a, b, c, in[1], 7);
	ROUND1(c, d, a, b, in[2], 11);
	ROUND1(b, c, d, a, in[3], 19);
	ROUND1(a, b, c, d, in[4], 3);
	ROUND1(d, a, b, c, in[5], 7);
	ROUND1(c, d, a, b, in[6], 11);
	ROUND1(b, c, d, a, in[7], 19);
	ROUND1(a, b, c, d, in[8], 3);
	ROUND1(d, a, b, c, in[9], 7);
	ROUND1(c, d, a, b, in[10], 11);
	ROUND1(b, c, d, a, in[11], 19);
	ROUND1(a, b, c, d, in[12], 3);
	ROUND1(d, a, b, c, in[13], 7);
	ROUND1(c, d, a, b, in[14], 11);
	ROUND1(b, c, d, a, in[15], 19);

	ROUND2(a, b, c, d,in[ 0], 3);
	ROUND2(d, a, b, c, in[4], 5);
	ROUND2(c, d, a, b, in[8], 9);
	ROUND2(b, c, d, a, in[12], 13);
	ROUND2(a, b, c, d, in[1], 3);
	ROUND2(d, a, b, c, in[5], 5);
	ROUND2(c, d, a, b, in[9], 9);
	ROUND2(b, c, d, a, in[13], 13);
	ROUND2(a, b, c, d, in[2], 3);
	ROUND2(d, a, b, c, in[6], 5);
	ROUND2(c, d, a, b, in[10], 9);
	ROUND2(b, c, d, a, in[14], 13);
	ROUND2(a, b, c, d, in[3], 3);
	ROUND2(d, a, b, c, in[7], 5);
	ROUND2(c, d, a, b, in[11], 9);
	ROUND2(b, c, d, a, in[15], 13);

	ROUND3(a, b, c, d,in[ 0], 3);
	ROUND3(d, a, b, c, in[8], 9);
	ROUND3(c, d, a, b, in[4], 11);
	ROUND3(b, c, d, a, in[12], 15);
	ROUND3(a, b, c, d, in[2], 3);
	ROUND3(d, a, b, c, in[10], 9);
	ROUND3(c, d, a, b, in[6], 11);
	ROUND3(b, c, d, a, in[14], 15);
	ROUND3(a, b, c, d, in[1], 3);
	ROUND3(d, a, b, c, in[9], 9);
	ROUND3(c, d, a, b, in[5], 11);
	ROUND3(b, c, d, a, in[13], 15);
	ROUND3(a, b, c, d, in[3], 3);
	ROUND3(d, a, b, c, in[11], 9);
	ROUND3(c, d, a, b, in[7], 11);
	ROUND3(b, c, d, a, in[15], 15);

	hash[0] += a;
	hash[1] += b;
	hash[2] += c;
	hash[3] += d;
}

static inline void md4_transform_helper(struct md4_ctx *ctx)
{
	le32_to_cpu_array(ctx->block, sizeof(ctx->block) / sizeof(uint32_t));
	md4_transform(ctx->hash, ctx->block);
}

static void md4_init(struct md4_ctx *mctx)
{
	mctx->hash[0] = 0x67452301;
	mctx->hash[1] = 0xefcdab89;
	mctx->hash[2] = 0x98badcfe;
	mctx->hash[3] = 0x10325476;
	mctx->byte_count = 0;
}

static void md4_update(struct md4_ctx *mctx,
		       const unsigned char *data, unsigned int len)
{
	const uint32_t avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);

	mctx->byte_count += len;

	if (avail > len) {
		memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
		       data, len);
		return;
	}

	memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
	       data, avail);

	md4_transform_helper(mctx);
	data += avail;
	len -= avail;

	while (len >= sizeof(mctx->block)) {
		memcpy(mctx->block, data, sizeof(mctx->block));
		md4_transform_helper(mctx);
		data += sizeof(mctx->block);
		len -= sizeof(mctx->block);
	}

	memcpy(mctx->block, data, len);
}

static void md4_final_ascii(struct md4_ctx *mctx, char *out, unsigned int len)
{
	const unsigned int offset = mctx->byte_count & 0x3f;
	char *p = (char *)mctx->block + offset;
	int padding = 56 - (offset + 1);

	*p++ = 0x80;
	if (padding < 0) {
		memset(p, 0x00, padding + sizeof (uint64_t));
		md4_transform_helper(mctx);
		p = (char *)mctx->block;
		padding = 56;
	}

	memset(p, 0, padding);
	mctx->block[14] = mctx->byte_count << 3;
	mctx->block[15] = mctx->byte_count >> 29;
	le32_to_cpu_array(mctx->block, (sizeof(mctx->block) -
	                  sizeof(uint64_t)) / sizeof(uint32_t));
	md4_transform(mctx->hash, mctx->block);
	cpu_to_le32_array(mctx->hash, sizeof(mctx->hash) / sizeof(uint32_t));

	snprintf(out, len, "%08X%08X%08X%08X",
		 mctx->hash[0], mctx->hash[1], mctx->hash[2], mctx->hash[3]);
}

static inline void add_char(unsigned char c, struct md4_ctx *md)
{
	md4_update(md, &c, 1);
}

static int parse_string(const char *file, unsigned long len,
			struct md4_ctx *md)
{
	unsigned long i;

	add_char(file[0], md);
	for (i = 1; i < len; i++) {
		add_char(file[i], md);
		if (file[i] == '"' && file[i-1] != '\\')
			break;
	}
	return i;
}

static int parse_comment(const char *file, unsigned long len)
{
	unsigned long i;

	for (i = 2; i < len; i++) {
		if (file[i-1] == '*' && file[i] == '/')
			break;
	}
	return i;
}

/* FIXME: Handle .s files differently (eg. # starts comments) --RR */
static int parse_file(const char *fname, struct md4_ctx *md)
{
	char *file;
	unsigned long i, len;

	file = grab_file(fname, &len);
	if (!file)
		return 0;

	for (i = 0; i < len; i++) {
		/* Collapse and ignore \ and CR. */
		if (file[i] == '\\' && (i+1 < len) && file[i+1] == '\n') {
			i++;
			continue;
		}

		/* Ignore whitespace */
		if (isspace(file[i]))
			continue;

		/* Handle strings as whole units */
		if (file[i] == '"') {
			i += parse_string(file+i, len - i, md);
			continue;
		}

		/* Comments: ignore */
		if (file[i] == '/' && file[i+1] == '*') {
			i += parse_comment(file+i, len - i);
			continue;
		}

		add_char(file[i], md);
	}
	release_file(file, len);
	return 1;
}

/* We have dir/file.o.  Open dir/.file.o.cmd, look for deps_ line to
 * figure out source file. */
static int parse_source_files(const char *objfile, struct md4_ctx *md)
{
	char *cmd, *file, *line, *dir;
	const char *base;
	unsigned long flen, pos = 0;
	int dirlen, ret = 0, check_files = 0;

	cmd = NOFAIL(malloc(strlen(objfile) + sizeof("..cmd")));

	base = strrchr(objfile, '/');
	if (base) {
		base++;
		dirlen = base - objfile;
		sprintf(cmd, "%.*s.%s.cmd", dirlen, objfile, base);
	} else {
		dirlen = 0;
		sprintf(cmd, ".%s.cmd", objfile);
	}
	dir = NOFAIL(malloc(dirlen + 1));
	strncpy(dir, objfile, dirlen);
	dir[dirlen] = '\0';

	file = grab_file(cmd, &flen);
	if (!file) {
		warn("could not find %s for %s\n", cmd, objfile);
		goto out;
	}

	/* There will be a line like so:
		deps_drivers/net/dummy.o := \
		  drivers/net/dummy.c \
		    $(wildcard include/config/net/fastroute.h) \
		  include/linux/config.h \
		    $(wildcard include/config/h.h) \
		  include/linux/module.h \

	   Sum all files in the same dir or subdirs.
	*/
	while ((line = get_next_line(&pos, file, flen)) != NULL) {
		char* p = line;
		if (strncmp(line, "deps_", sizeof("deps_")-1) == 0) {
			check_files = 1;
			continue;
		}
		if (!check_files)
			continue;

		/* Continue until line does not end with '\' */
		if ( *(p + strlen(p)-1) != '\\')
			break;
		/* Terminate line at first space, to get rid of final ' \' */
		while (*p) {
                       if (isspace(*p)) {
				*p = '\0';
				break;
			}
			p++;
		}

		/* Check if this file is in same dir as objfile */
		if ((strstr(line, dir)+strlen(dir)-1) == strrchr(line, '/')) {
			if (!parse_file(line, md)) {
				warn("could not open %s: %s\n",
				     line, strerror(errno));
				goto out_file;
			}

		}

	}

	/* Everyone parsed OK */
	ret = 1;
out_file:
	release_file(file, flen);
out:
	free(dir);
	free(cmd);
	return ret;
}

/* Calc and record src checksum. */
void get_src_version(const char *modname, char sum[], unsigned sumlen)
{
	void *file;
	unsigned long len;
	struct md4_ctx md;
	char *sources, *end, *fname;
	const char *basename;
	char filelist[PATH_MAX + 1];
	char *modverdir = getenv("MODVERDIR");

	if (!modverdir)
		modverdir = ".";

	/* Source files for module are in .tmp_versions/modname.mod,
	   after the first line. */
	if (strrchr(modname, '/'))
		basename = strrchr(modname, '/') + 1;
	else
		basename = modname;
	sprintf(filelist, "%s/%.*s.mod", modverdir,
		(int) strlen(basename) - 2, basename);

	file = grab_file(filelist, &len);
	if (!file) {
		warn("could not find versions for %s\n", filelist);
		return;
	}

	sources = strchr(file, '\n');
	if (!sources) {
		warn("malformed versions file for %s\n", modname);
		goto release;
	}

	sources++;
	end = strchr(sources, '\n');
	if (!end) {
		warn("bad ending versions file for %s\n", modname);
		goto release;
	}
	*end = '\0';

	md4_init(&md);
	while ((fname = strsep(&sources, " ")) != NULL) {
		if (!*fname)
			continue;
		if (!parse_source_files(fname, &md))
			goto release;
	}

	md4_final_ascii(&md, sum, sumlen);
release:
	release_file(file, len);
}

static void write_version(const char *filename, const char *sum,
			  unsigned long offset)
{
	int fd;

	fd = open(filename, O_RDWR);
	if (fd < 0) {
		warn("changing sum in %s failed: %s\n",
			filename, strerror(errno));
		return;
	}

	if (lseek(fd, offset, SEEK_SET) == (off_t)-1) {
		warn("changing sum in %s:%lu failed: %s\n",
			filename, offset, strerror(errno));
		goto out;
	}

	if (write(fd, sum, strlen(sum)+1) != strlen(sum)+1) {
		warn("writing sum in %s failed: %s\n",
			filename, strerror(errno));
		goto out;
	}
out:
	close(fd);
}

static int strip_rcs_crap(char *version)
{
	unsigned int len, full_len;

	if (strncmp(version, "$Revision", strlen("$Revision")) != 0)
		return 0;

	/* Space for version string follows. */
	full_len = strlen(version) + strlen(version + strlen(version) + 1) + 2;

	/* Move string to start with version number: prefix will be
	 * $Revision$ or $Revision: */
	len = strlen("$Revision");
	if (version[len] == ':' || version[len] == '$')
		len++;
	while (isspace(version[len]))
		len++;
	memmove(version, version+len, full_len-len);
	full_len -= len;

	/* Preserve up to next whitespace. */
	len = 0;
	while (version[len] && !isspace(version[len]))
		len++;
	memmove(version + len, version + strlen(version),
		full_len - strlen(version));
	return 1;
}

/* Clean up RCS-style version numbers. */
void maybe_frob_rcs_version(const char *modfilename,
			    char *version,
			    void *modinfo,
			    unsigned long version_offset)
{
	if (strip_rcs_crap(version))
		write_version(modfilename, version, version_offset);
}
Commit	Line	Data
1da177e4 LT	1	#include <netinet/in.h>
	2	#ifdef __sun__
	3	#include <inttypes.h>
	4	#else
	5	#include <stdint.h>
	6	#endif
	7	#include <ctype.h>
	8	#include <errno.h>
	9	#include <string.h>
	10	#include "modpost.h"
	11
	12	/*
	13	* Stolen form Cryptographic API.
	14	*
	15	* MD4 Message Digest Algorithm (RFC1320).
	16	*
	17	* Implementation derived from Andrew Tridgell and Steve French's
	18	* CIFS MD4 implementation, and the cryptoapi implementation
	19	* originally based on the public domain implementation written
	20	* by Colin Plumb in 1993.
	21	*
	22	* Copyright (c) Andrew Tridgell 1997-1998.
	23	* Modified by Steve French ([email protected]) 2002
	24	* Copyright (c) Cryptoapi developers.
	25	* Copyright (c) 2002 David S. Miller ([email protected])
	26	* Copyright (c) 2002 James Morris <[email protected]>
	27	*
	28	* This program is free software; you can redistribute it and/or modify
	29	* it under the terms of the GNU General Public License as published by
	30	* the Free Software Foundation; either version 2 of the License, or
	31	* (at your option) any later version.
	32	*
	33	*/
	34	#define MD4_DIGEST_SIZE 16
	35	#define MD4_HMAC_BLOCK_SIZE 64
	36	#define MD4_BLOCK_WORDS 16
	37	#define MD4_HASH_WORDS 4
	38
	39	struct md4_ctx {
	40	uint32_t hash[MD4_HASH_WORDS];
	41	uint32_t block[MD4_BLOCK_WORDS];
	42	uint64_t byte_count;
	43	};
	44
	45	static inline uint32_t lshift(uint32_t x, unsigned int s)
	46	{
	47	x &= 0xFFFFFFFF;
	48	return ((x << s) & 0xFFFFFFFF) \| (x >> (32 - s));
	49	}
	50
	51	static inline uint32_t F(uint32_t x, uint32_t y, uint32_t z)
	52	{
	53	return (x & y) \| ((~x) & z);
	54	}
	55
	56	static inline uint32_t G(uint32_t x, uint32_t y, uint32_t z)
	57	{
	58	return (x & y) \| (x & z) \| (y & z);
	59	}
	60
	61	static inline uint32_t H(uint32_t x, uint32_t y, uint32_t z)
	62	{
	63	return x ^ y ^ z;
	64	}
65
66	#define ROUND1(a,b,c,d,k,s) (a = lshift(a + F(b,c,d) + k, s))
67	#define ROUND2(a,b,c,d,k,s) (a = lshift(a + G(b,c,d) + k + (uint32_t)0x5A827999,s))
68	#define ROUND3(a,b,c,d,k,s) (a = lshift(a + H(b,c,d) + k + (uint32_t)0x6ED9EBA1,s))
69
70	/* XXX: this stuff can be optimized */
71	static inline void le32_to_cpu_array(uint32_t *buf, unsigned int words)
72	{
73	while (words--) {
74	buf = ntohl(buf);
75	buf++;
76	}
77	}
78
79	static inline void cpu_to_le32_array(uint32_t *buf, unsigned int words)
80	{
81	while (words--) {
82	buf = htonl(buf);
83	buf++;
84	}
85	}
86
87	static void md4_transform(uint32_t hash, uint32_t const in)
88	{
89	uint32_t a, b, c, d;
90
91	a = hash[0];
92	b = hash[1];
93	c = hash[2];
94	d = hash[3];
95
96	ROUND1(a, b, c, d, in[0], 3);
97	ROUND1(d, a, b, c, in[1], 7);
98	ROUND1(c, d, a, b, in[2], 11);
99	ROUND1(b, c, d, a, in[3], 19);
100	ROUND1(a, b, c, d, in[4], 3);
101	ROUND1(d, a, b, c, in[5], 7);
102	ROUND1(c, d, a, b, in[6], 11);
103	ROUND1(b, c, d, a, in[7], 19);
104	ROUND1(a, b, c, d, in[8], 3);
105	ROUND1(d, a, b, c, in[9], 7);
106	ROUND1(c, d, a, b, in[10], 11);
107	ROUND1(b, c, d, a, in[11], 19);
108	ROUND1(a, b, c, d, in[12], 3);
109	ROUND1(d, a, b, c, in[13], 7);
110	ROUND1(c, d, a, b, in[14], 11);
111	ROUND1(b, c, d, a, in[15], 19);
112
113	ROUND2(a, b, c, d,in[ 0], 3);
114	ROUND2(d, a, b, c, in[4], 5);
115	ROUND2(c, d, a, b, in[8], 9);
116	ROUND2(b, c, d, a, in[12], 13);
117	ROUND2(a, b, c, d, in[1], 3);
118	ROUND2(d, a, b, c, in[5], 5);
119	ROUND2(c, d, a, b, in[9], 9);
120	ROUND2(b, c, d, a, in[13], 13);
121	ROUND2(a, b, c, d, in[2], 3);
122	ROUND2(d, a, b, c, in[6], 5);
123	ROUND2(c, d, a, b, in[10], 9);
124	ROUND2(b, c, d, a, in[14], 13);
125	ROUND2(a, b, c, d, in[3], 3);
126	ROUND2(d, a, b, c, in[7], 5);
127	ROUND2(c, d, a, b, in[11], 9);
128	ROUND2(b, c, d, a, in[15], 13);
129
130	ROUND3(a, b, c, d,in[ 0], 3);
131	ROUND3(d, a, b, c, in[8], 9);
132	ROUND3(c, d, a, b, in[4], 11);
133	ROUND3(b, c, d, a, in[12], 15);
134	ROUND3(a, b, c, d, in[2], 3);
135	ROUND3(d, a, b, c, in[10], 9);
136	ROUND3(c, d, a, b, in[6], 11);
137	ROUND3(b, c, d, a, in[14], 15);
138	ROUND3(a, b, c, d, in[1], 3);
139	ROUND3(d, a, b, c, in[9], 9);
140	ROUND3(c, d, a, b, in[5], 11);
141	ROUND3(b, c, d, a, in[13], 15);
142	ROUND3(a, b, c, d, in[3], 3);
143	ROUND3(d, a, b, c, in[11], 9);
144	ROUND3(c, d, a, b, in[7], 11);
145	ROUND3(b, c, d, a, in[15], 15);
146
147	hash[0] += a;
148	hash[1] += b;
149	hash[2] += c;
150	hash[3] += d;
151	}
152
153	static inline void md4_transform_helper(struct md4_ctx *ctx)
154	{
155	le32_to_cpu_array(ctx->block, sizeof(ctx->block) / sizeof(uint32_t));
156	md4_transform(ctx->hash, ctx->block);
157	}
158
159	static void md4_init(struct md4_ctx *mctx)
160	{
161	mctx->hash[0] = 0x67452301;
162	mctx->hash[1] = 0xefcdab89;
163	mctx->hash[2] = 0x98badcfe;
164	mctx->hash[3] = 0x10325476;
165	mctx->byte_count = 0;
166	}
167
168	static void md4_update(struct md4_ctx *mctx,
169	const unsigned char *data, unsigned int len)
170	{
171	const uint32_t avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
172
173	mctx->byte_count += len;
174
175	if (avail > len) {
176	memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
177	data, len);
178	return;
179	}
180
181	memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
182	data, avail);
183
184	md4_transform_helper(mctx);
185	data += avail;
186	len -= avail;
187
188	while (len >= sizeof(mctx->block)) {
189	memcpy(mctx->block, data, sizeof(mctx->block));
190	md4_transform_helper(mctx);
191	data += sizeof(mctx->block);
192	len -= sizeof(mctx->block);
193	}
194
195	memcpy(mctx->block, data, len);
196	}
197
198	static void md4_final_ascii(struct md4_ctx mctx, char out, unsigned int len)
199	{
200	const unsigned int offset = mctx->byte_count & 0x3f;
201	char p = (char )mctx->block + offset;
202	int padding = 56 - (offset + 1);
203
204	*p++ = 0x80;
205	if (padding < 0) {
206	memset(p, 0x00, padding + sizeof (uint64_t));
207	md4_transform_helper(mctx);
208	p = (char *)mctx->block;
209	padding = 56;
210	}
211
212	memset(p, 0, padding);
213	mctx->block[14] = mctx->byte_count << 3;
214	mctx->block[15] = mctx->byte_count >> 29;
215	le32_to_cpu_array(mctx->block, (sizeof(mctx->block) -
216	sizeof(uint64_t)) / sizeof(uint32_t));
217	md4_transform(mctx->hash, mctx->block);
218	cpu_to_le32_array(mctx->hash, sizeof(mctx->hash) / sizeof(uint32_t));
219
220	snprintf(out, len, "%08X%08X%08X%08X",
221	mctx->hash[0], mctx->hash[1], mctx->hash[2], mctx->hash[3]);
222	}
223
224	static inline void add_char(unsigned char c, struct md4_ctx *md)
225	{
226	md4_update(md, &c, 1);
227	}
228
229	static int parse_string(const char *file, unsigned long len,
230	struct md4_ctx *md)
231	{
232	unsigned long i;
233
234	add_char(file[0], md);
235	for (i = 1; i < len; i++) {
236	add_char(file[i], md);
237	if (file[i] == '"' && file[i-1] != '\\')
238	break;
239	}
240	return i;
241	}
242
243	static int parse_comment(const char *file, unsigned long len)
244	{
245	unsigned long i;
246
247	for (i = 2; i < len; i++) {
248	if (file[i-1] == '*' && file[i] == '/')
249	break;
250	}
251	return i;
252	}
253
254	/* FIXME: Handle .s files differently (eg. # starts comments) --RR */
61d9cdf2	255	static int parse_file(const char fname, struct md4_ctx md)
1da177e4	256	{
61d9cdf2	257	char *file;
1da177e4 LT	258	unsigned long i, len;
	259
	260	file = grab_file(fname, &len);
	261	if (!file)
	262	return 0;
	263
	264	for (i = 0; i < len; i++) {
	265	/* Collapse and ignore \ and CR. */
	266	if (file[i] == '\\' && (i+1 < len) && file[i+1] == '\n') {
	267	i++;
	268	continue;
	269	}
	270
	271	/* Ignore whitespace */
	272	if (isspace(file[i]))
	273	continue;
	274
	275	/* Handle strings as whole units */
	276	if (file[i] == '"') {
	277	i += parse_string(file+i, len - i, md);
	278	continue;
	279	}
	280
	281	/* Comments: ignore */
	282	if (file[i] == '/' && file[i+1] == '*') {
	283	i += parse_comment(file+i, len - i);
	284	continue;
	285	}
	286
	287	add_char(file[i], md);
	288	}
	289	release_file(file, len);
	290	return 1;
	291	}
	292
	293	/* We have dir/file.o. Open dir/.file.o.cmd, look for deps_ line to
	294	* figure out source file. */
	295	static int parse_source_files(const char objfile, struct md4_ctx md)
	296	{
	297	char cmd, file, line, dir;
	298	const char *base;
	299	unsigned long flen, pos = 0;
	300	int dirlen, ret = 0, check_files = 0;
	301
	302	cmd = NOFAIL(malloc(strlen(objfile) + sizeof("..cmd")));
	303
	304	base = strrchr(objfile, '/');
	305	if (base) {
	306	base++;
	307	dirlen = base - objfile;
	308	sprintf(cmd, "%.*s.%s.cmd", dirlen, objfile, base);
	309	} else {
	310	dirlen = 0;
	311	sprintf(cmd, ".%s.cmd", objfile);
	312	}
	313	dir = NOFAIL(malloc(dirlen + 1));
	314	strncpy(dir, objfile, dirlen);
	315	dir[dirlen] = '\0';
	316
	317	file = grab_file(cmd, &flen);
	318	if (!file) {
cb80514d	319	warn("could not find %s for %s\n", cmd, objfile);
1da177e4 LT	320	goto out;
	321	}
	322
	323	/* There will be a line like so:
	324	deps_drivers/net/dummy.o := \
	325	drivers/net/dummy.c \
	326	$(wildcard include/config/net/fastroute.h) \
	327	include/linux/config.h \
	328	$(wildcard include/config/h.h) \
	329	include/linux/module.h \
	330
	331	Sum all files in the same dir or subdirs.
	332	*/
	333	while ((line = get_next_line(&pos, file, flen)) != NULL) {
61d9cdf2	334	char* p = line;
1da177e4 LT	335	if (strncmp(line, "deps_", sizeof("deps_")-1) == 0) {
	336	check_files = 1;
	337	continue;
	338	}
	339	if (!check_files)
	340	continue;
	341
	342	/* Continue until line does not end with '\' */
	343	if ( *(p + strlen(p)-1) != '\\')
	344	break;
	345	/* Terminate line at first space, to get rid of final ' \' */
	346	while (*p) {
	347	if (isspace(*p)) {
	348	*p = '\0';
	349	break;
	350	}
	351	p++;
	352	}
	353
	354	/* Check if this file is in same dir as objfile */
	355	if ((strstr(line, dir)+strlen(dir)-1) == strrchr(line, '/')) {
	356	if (!parse_file(line, md)) {
cb80514d SR	357	warn("could not open %s: %s\n",
cb80514d SR	358	line, strerror(errno));
1da177e4 LT	359	goto out_file;
	360	}
	361
	362	}
	363
	364	}
	365
	366	/* Everyone parsed OK */
	367	ret = 1;
	368	out_file:
	369	release_file(file, flen);
	370	out:
	371	free(dir);
	372	free(cmd);
	373	return ret;
	374	}
	375
	376	/* Calc and record src checksum. */
	377	void get_src_version(const char *modname, char sum[], unsigned sumlen)
	378	{
	379	void *file;
	380	unsigned long len;
	381	struct md4_ctx md;
	382	char sources, end, *fname;
	383	const char *basename;
41370d3b SR	384	char filelist[PATH_MAX + 1];
	385	char *modverdir = getenv("MODVERDIR");
	386
	387	if (!modverdir)
	388	modverdir = ".";
1da177e4 LT	389
	390	/* Source files for module are in .tmp_versions/modname.mod,
	391	after the first line. */
	392	if (strrchr(modname, '/'))
	393	basename = strrchr(modname, '/') + 1;
	394	else
	395	basename = modname;
41370d3b	396	sprintf(filelist, "%s/%.*s.mod", modverdir,
1da177e4 LT	397	(int) strlen(basename) - 2, basename);
	398
	399	file = grab_file(filelist, &len);
	400	if (!file) {
cb80514d	401	warn("could not find versions for %s\n", filelist);
1da177e4 LT	402	return;
	403	}
	404
	405	sources = strchr(file, '\n');
	406	if (!sources) {
cb80514d	407	warn("malformed versions file for %s\n", modname);
1da177e4 LT	408	goto release;
	409	}
	410
	411	sources++;
	412	end = strchr(sources, '\n');
	413	if (!end) {
cb80514d	414	warn("bad ending versions file for %s\n", modname);
1da177e4 LT	415	goto release;
	416	}
	417	*end = '\0';
	418
	419	md4_init(&md);
	420	while ((fname = strsep(&sources, " ")) != NULL) {
	421	if (!*fname)
	422	continue;
	423	if (!parse_source_files(fname, &md))
	424	goto release;
	425	}
	426
	427	md4_final_ascii(&md, sum, sumlen);
	428	release:
	429	release_file(file, len);
	430	}
	431
	432	static void write_version(const char filename, const char sum,
	433	unsigned long offset)
	434	{
	435	int fd;
	436
	437	fd = open(filename, O_RDWR);
	438	if (fd < 0) {
cb80514d	439	warn("changing sum in %s failed: %s\n",
1da177e4 LT	440	filename, strerror(errno));
	441	return;
	442	}
	443
	444	if (lseek(fd, offset, SEEK_SET) == (off_t)-1) {
cb80514d	445	warn("changing sum in %s:%lu failed: %s\n",
1da177e4 LT	446	filename, offset, strerror(errno));
	447	goto out;
	448	}
	449
	450	if (write(fd, sum, strlen(sum)+1) != strlen(sum)+1) {
cb80514d	451	warn("writing sum in %s failed: %s\n",
1da177e4 LT	452	filename, strerror(errno));
	453	goto out;
	454	}
	455	out:
	456	close(fd);
	457	}
	458
61d9cdf2	459	static int strip_rcs_crap(char *version)
1da177e4 LT	460	{
	461	unsigned int len, full_len;
	462
	463	if (strncmp(version, "$Revision", strlen("$Revision")) != 0)
	464	return 0;
	465
	466	/* Space for version string follows. */
	467	full_len = strlen(version) + strlen(version + strlen(version) + 1) + 2;
	468
	469	/* Move string to start with version number: prefix will be
	470	* $Revision$ or $Revision: */
	471	len = strlen("$Revision");
	472	if (version[len] == ':' \|\| version[len] == '$')
	473	len++;
	474	while (isspace(version[len]))
	475	len++;
	476	memmove(version, version+len, full_len-len);
	477	full_len -= len;
	478
	479	/* Preserve up to next whitespace. */
	480	len = 0;
	481	while (version[len] && !isspace(version[len]))
	482	len++;
	483	memmove(version + len, version + strlen(version),
	484	full_len - strlen(version));
	485	return 1;
	486	}
	487
	488	/* Clean up RCS-style version numbers. */
	489	void maybe_frob_rcs_version(const char *modfilename,
	490	char *version,
	491	void *modinfo,
	492	unsigned long version_offset)
	493	{
	494	if (strip_rcs_crap(version))
	495	write_version(modfilename, version, version_offset);
	496	}