OBJDUMP=/usr/bin/objdump		# Ubicació del binari objdump
NEW_KERNEL=/usr/src/linux		# Fonts del nou kernel (¡¡compil.lat!!)
patcher=/usr/local/bin/patch	# Ruta del binari patch
 
CRC_CHECK=_R\?[a-f0-9]\{8\}
 
clear
 
#
# Trivialitats: comprobar arguments i presència del mòdul:
#
if [ ! $# -eq 1 ]; then
	echo "Uso: ${0} modulo.o"
	exit 1
fi
 
if [ ! -r $1  ]; then
	echo "El modulo $1 no es legible."
	exit 2
else
	#
	# Assegurar-se que es de la rama 2.4.X
	#
	version=`/sbin/modinfo $1|grep -o "2\.4"`
	if [ -z "$version" ]; then
		echo "$MODULE no esta compilado para la rama 2.4.X"
		exit 3
	fi
fi
 
#
# Asegurarse que tenim el nou kernel compil.lat amb els CRCs:
#
echo ">> Comprobando kernel nuevo ... "
if [ ! -d ${NEW_KERNEL}/include/linux/modules/ ]; then
	echo -ne "\tError, falta la información de CRC del nuevo kernel.\n"
	exit 2
else
	#
	# Buscar los archivos .ver:
	#
	ls ${NEW_KERNEL}/include/linux/modules/*.ver >/dev/null
	if [ $? -eq 1 ]; then
		echo -ne "\tError, compilacion incompleta del kernel.\n"
		exit 3
	fi
fi
echo -ne "\t\a[CORRECTO!]\n"
 
MODULE=$1
FILE_SYMBOLS=./${MODULE}.syms
 
#
# Si existeix un fitxer patch previ esborrar :
#
if [ -w ./$MODULE.patch ]; then
	rm -f ./$MODULE.patch
fi
 
# Obtenir els símbols no definitis del mòdul i generar fitxer:
echo ">> Generando archivo de símbolos no definidos ... "
`${OBJDUMP} --syms ${MODULE}|grep "*UND*"|tr -s ' ' ' '|cut -d" " -f3 \
	> ${FILE_SYMBOLS}`
 
# Descartar els símbols sense CRC :
echo ">> Agrupando símbolos con CRC ..."
symbols=`cat ${FILE_SYMBOLS}|grep -i -E ${CRC_CHECK}`
 
#
# Símbol a símbol, obtenir el seu CRC, buscar el nou al kernel i comparar
# ambdos. Si son diferents, afegir símbol amb NOU CRC al fitxer de patch:
#
for iSymbol in ${symbols}
do
 
	strlen=`expr length ${iSymbol}`
	issmp=`echo ${iSymbol}|grep -i Rsmp`
	if [ ! -z $issmp ]; then
		noCRC=`expr ${strlen} - 14`
	else
		noCRC=`expr ${strlen} - 10`	# Sense smp ...
	fi
 
	# Desar el nom del símbol i el seu CRC ... :
	CRCa=`echo ${iSymbol:noCRC}`
	if [ ! -z ${issmp} ]; then
		CRC=${CRCa:6}
	else
		CRC=${CRCa:2}			# Sense smp ...
	fi
	nSymbol=${iSymbol:0:noCRC}	# Desar nom del símbol
	echo -ne "Símbolo: ${nSymbol} , CRC=${CRC}"
 
	#
	# Buscar aquest símbol al nou kernel
	#
	newSymbol=`grep -h -E "#define __ver_$nSymbol\\t*" $NEW_KERNEL/include/linux/modules/*.ver`
	i=0
	for string in $newSymbol
	do
		i=`expr $i + 1`
		# Obtenim el nou CRC ...
		if [ $i -eq 3 ]; then
			if [ "${string:0:4}" == "smp_" ]; then
				NEW_CRC=${string:4}		# smp_CRC
			else
				NEW_CRC=${string}
			fi
			# Comparar ...
			if [ "$CRC" == "$NEW_CRC" ]; then
				echo " : [COINCIDEN]"
			else
				echo " : [CRC ERROR: $NEW_CRC]"
				# Volcar a fitxer :
				echo -e "${nSymbol} ${CRC} ${NEW_CRC}" >> ./${MODULE}.patch
			fi
		fi
	done
done
 
#
# Aplicar el patch sobre el mòdul, generant: patched.o
#
if [ -r ${MODULE}.patch ]; then
	echo -ne "Aplicando parche sobre módulo ${MODULE} ... "
	${patcher} ./${MODULE}.patch ./${MODULE}
	if [ $? -eq 0 ]; then
		echo "[OK, modulo parcheado en ./patched.o]"
	else
		echo "[ERROR]"
	fi
fi
 
#
# Purgar el fitxer temporal de símbols :
#
rm -f ./${MODULE}.syms 2>/dev/null

#include <stdio.h>
#include <sys/fcntl.h>				/* O_RDONLY	 */
#include <sys/stat.h>				/* fstat     */
#include <limits.h>					/* SSIZE_MAX */
#include <string.h>					/* memmem */
 
#define MAX_SYMBOL_SIZE	256
#define MAX_CRC_SIZE	9
#define MAX_LINE_SIZE	( MAX_SYMBOL_SIZE + MAX_CRC_SIZE )
 
const char *FORMAT = "%s %s %s", * buffer = NULL;
 
void patch_module (char *, char *, char *, int);
 
int main (int argc, char **argv){
 
	FILE *fpatch = NULL;
	char * symbol, * CRC, * NEW_CRC;
	int fmod, fout, bRead=0;
	struct stat fmod_stat;
 
#ifdef _DEBUG_
	printf("DEBUG_MSG: SSIZE_MAX: %d bytes.\n", SSIZE_MAX);
#endif
 
	if(argc!=3){
		printf("Uso: %s modulo.o.patch modulo.o\n",
				*argv);
		return -1;
	}
 
	/* Llegir el fitxer línea a línea */
	if((fpatch=fopen(*(argv+1),"r"))==NULL){
		perror("FOPEN"); return -2;
	}
 
	/* Obrir el mòdul binari : */
	if((fmod=open(*(argv+2),O_RDONLY))==-1){
		perror("OPEN"); return -3;
	}
 
	/* Obtenir tamany del fitxer */
	if(fstat(fmod,&fmod_stat)==-1){
		perror("FSTAT"); return -4;
	}
 
	/* Reservar el tamany del fitxer si es inferior o igual al màxim */
	if(fmod_stat.st_size<SSIZE_MAX ? fmod_stat.st_size : SSIZE_MAX))==-1)
	{
		perror("READ"); free(buffer); close(fmod); return -4;
	} close(fmod);
 
#ifdef _DEBUG_
	printf("DEBUG_MSG: Leidos %d bytes del modulo sobre %0xd.\n", bRead,
						buffer);
#endif
 
	/* Reservar memoria */
	symbol = (char *)malloc(sizeof(char)*MAX_SYMBOL_SIZE);
	CRC  = (char *)malloc(sizeof(char)*MAX_CRC_SIZE);
	NEW_CRC  = (char *)malloc(sizeof(char)*MAX_CRC_SIZE);
 
	/* Simbol a símbol, obtenir el CRC i passar-ho a patch_mod */
	while(!feof(fpatch)){
		memset(symbol,0,MAX_SYMBOL_SIZE-1);
		memset(CRC,0,MAX_CRC_SIZE-1);
		if(fscanf(fpatch,FORMAT,symbol,CRC,NEW_CRC)==EOF)break;
		patch_module(symbol,CRC,NEW_CRC,bRead);
	}
 
	/* Desar memoria a fitxer : */
	if((fout=open("patched.o",O_CREAT|O_TRUNC|O_WRONLY,
						S_IRWXU|S_IRGRP|S_IROTH))==-1)perror("OPEN");
	else {
		if((bRead=write(fout,buffer,bRead))==-1)perror("WRITE");
#ifdef _DEBUG_
		printf("DEBUG_MSG: Escritos %d bytes sobre patched.o.\n",bRead);
#endif
		close(fout);
	}
 
	// Purgar i netejar :
	free(symbol); free(CRC); free(NEW_CRC); free(buffer);
	fclose(fpatch);
 
	return 0;
}
 
//
// Busca el CRC antic dins del buffer del mòdul, i el substitueix pel
// nou CRC.
//
void patch_module (char * symbolName, char * oldCRC, char * newCRC,
					int bufferLength) {
 
	void * pCRC = NULL;
	char curCRC[9], * pBuffer = buffer;
	int iByte;
 
#ifdef _DEBUG_
	printf("Buscando CRC: %s en %0xd ... ", oldCRC, buffer);
#endif
	if((pCRC = memmem(buffer,bufferLength,oldCRC,8))==NULL) {
#ifdef _DEBUG_
		printf("[ERROR!!]");					// CRC no trobat !
#endif
	} else {
		memcpy(curCRC,pCRC,8); curCRC[8]='\0';
#ifdef _DEBUG_
		printf("OK, posicion: %0xd (%s).\n\tParcheando por %s ... ",
				pCRC, curCRC, newCRC);
#endif
		pBuffer = pCRC;							// Posicionarnos
		for(iByte=0;iByte<=7;iByte++)			// Aplicar els bytes nous
			*(pBuffer+iByte)=*(newCRC+iByte);
#ifdef _DEBUG_
		memcpy(curCRC,pCRC,8);
		printf("\n\tContenido de %0xd = %s", pCRC, curCRC);
#endif
	}
	printf("\n");
}