rpl/src/instructions_d6.c - diff

Return to instructions_d6.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_d6.c between versions 1.45 and 1.55

version 1.45, 2013/02/27 14:12:57	version 1.55, 2014/07/17 08:07:20
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.12	RPL/2 (R) version 4.1.19
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2014 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.

Line 339 instruction_diag_fleche(struct_processus	Line 339 instruction_diag_fleche(struct_processus
struct_objet *s_objet_argument;	struct_objet *s_objet_argument;
struct_objet *s_objet_resultat;	struct_objet *s_objet_resultat;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;

(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

Line 409 instruction_diag_fleche(struct_processus	Line 409 instruction_diag_fleche(struct_processus
(((struct_matrice ) (*s_objet_argument).objet)).nombre_lignes;	(((struct_matrice ) (*s_objet_argument).objet)).nombre_lignes;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau
= malloc((((struct_vecteur ) (*s_objet_resultat).objet))	= malloc(((size_t) (((struct_vecteur ) (*s_objet_resultat)
.taille * sizeof(integer8))) == NULL)	.objet)).taille) * sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 467 instruction_diag_fleche(struct_processus	Line 467 instruction_diag_fleche(struct_processus
(((struct_matrice ) (*s_objet_argument).objet)).nombre_lignes;	(((struct_matrice ) (*s_objet_argument).objet)).nombre_lignes;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau
= malloc((((struct_vecteur ) (*s_objet_resultat).objet))	= malloc(((size_t) (((struct_vecteur ) (*s_objet_resultat)
.taille * sizeof(real8))) == NULL)	.objet)).taille) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 525 instruction_diag_fleche(struct_processus	Line 525 instruction_diag_fleche(struct_processus
(((struct_matrice ) (*s_objet_argument).objet)).nombre_lignes;	(((struct_matrice ) (*s_objet_argument).objet)).nombre_lignes;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau
= malloc((((struct_vecteur ) (*s_objet_resultat).objet))	= malloc(((size_t) (((struct_vecteur ) (*s_objet_resultat)
.taille * sizeof(complex16))) == NULL)	.objet)).taille) * sizeof(complex16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 610 instruction_digest(struct_processus *s_e	Line 610 instruction_digest(struct_processus *s_e
const EVP_MD *EVP_sum;	const EVP_MD *EVP_sum;
const EVP_CIPHER *EVP_chiffrement;	const EVP_CIPHER *EVP_chiffrement;

logical1 somme_invalide;	int i;
	int longueur_bloc;
	int longueur_somme;

	integer8 longueur_chaine;
	integer8 longueur_clef;
	integer8 longueur_clef_attendue;
	integer8 longueur_clef_max;
	integer8 longueur_clef_min;
	integer8 longueur_tampon;

long i;	logical1 somme_invalide;
long longueur_chaine;

struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;

Line 628 instruction_digest(struct_processus *s_e	Line 636 instruction_digest(struct_processus *s_e
unsigned char *tampon;	unsigned char *tampon;
unsigned char *vecteur_initialisation;	unsigned char *vecteur_initialisation;

unsigned int longueur_bloc;
unsigned int longueur_somme;
unsigned int longueur_tampon;

unsigned long longueur_clef;
unsigned long longueur_clef_attendue;
unsigned long longueur_clef_max;
unsigned long longueur_clef_min;

(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

if ((*s_etat_processus).affichage_arguments == 'Y')	if ((*s_etat_processus).affichage_arguments == 'Y')
Line 1356 instruction_digest(struct_processus *s_e	Line 1355 instruction_digest(struct_processus *s_e
return;	return;
}	}

if (EVP_DigestUpdate(&contexte, chaine, longueur_chaine) != 1)	if (EVP_DigestUpdate(&contexte, chaine, (size_t) longueur_chaine) != 1)
{	{
free(chaine);	free(chaine);
EVP_MD_CTX_cleanup(&contexte);	EVP_MD_CTX_cleanup(&contexte);
Line 2268 instruction_digest(struct_processus *s_e	Line 2267 instruction_digest(struct_processus *s_e
}	}
}	}

if ((vecteur_initialisation = malloc(longueur_clef *	if ((vecteur_initialisation = malloc(((size_t) longueur_clef) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 2276 instruction_digest(struct_processus *s_e	Line 2275 instruction_digest(struct_processus *s_e
return;	return;
}	}

memset(vecteur_initialisation, 0, longueur_clef);	memset(vecteur_initialisation, 0, (size_t) longueur_clef);

if ((tampon = chiffrement(EVP_chiffrement, d_vrai,	if ((tampon = chiffrement(EVP_chiffrement, d_vrai,
chaine, longueur_chaine, clef, longueur_clef,	chaine, longueur_chaine, clef, longueur_clef,
Line 2346 instruction_digest(struct_processus *s_e	Line 2345 instruction_digest(struct_processus *s_e
longueur_tampon = longueur_clef;	longueur_tampon = longueur_clef;
tampon = clef;	tampon = clef;

if ((clef = malloc(longueur_bloc * sizeof(unsigned char)))	if ((clef = malloc(((size_t) longueur_bloc) *
== NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
return;	return;
}	}

memset(clef, 0, longueur_bloc);	memset(clef, 0, (size_t) longueur_bloc);
memcpy(clef, tampon, longueur_tampon);	memcpy(clef, tampon, (size_t) longueur_tampon);
longueur_clef = longueur_bloc;	longueur_clef = longueur_bloc;
free(tampon);	free(tampon);
}	}
Line 2364 instruction_digest(struct_processus *s_e	Line 2363 instruction_digest(struct_processus *s_e
longueur_tampon = longueur_clef;	longueur_tampon = longueur_clef;
tampon = clef;	tampon = clef;

if ((clef = malloc(longueur_bloc * sizeof(unsigned char)))	if ((clef = malloc(((size_t) longueur_bloc) *
== NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
return;	return;
}	}

memcpy(clef, tampon, longueur_bloc);	memcpy(clef, tampon, (size_t) longueur_bloc);
longueur_clef = longueur_bloc;	longueur_clef = longueur_bloc;
free(tampon);	free(tampon);
}	}

for(i = 0; i < longueur_bloc; i++)	for(i = 0; i < longueur_bloc; i++)
{	{
clef[i] ^= 0x36;	clef[i] ^= (unsigned char) 0x36;
}	}

if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)	if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
Line 2393 instruction_digest(struct_processus *s_e	Line 2392 instruction_digest(struct_processus *s_e
return;	return;
}	}

if ((tampon = malloc((longueur_bloc + longueur_chaine) *	if ((tampon = malloc(((size_t) (longueur_bloc + longueur_chaine)) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

memcpy(tampon, clef, longueur_bloc);	memcpy(tampon, clef, (size_t) longueur_bloc);
memcpy(tampon + longueur_bloc, chaine, longueur_chaine);	memcpy(tampon + longueur_bloc, chaine, (size_t) longueur_chaine);
longueur_tampon = longueur_bloc + longueur_chaine;	longueur_tampon = longueur_bloc + longueur_chaine;

if (EVP_DigestInit(&contexte, EVP_sum) != 1)	if (EVP_DigestInit(&contexte, EVP_sum) != 1)
Line 2419 instruction_digest(struct_processus *s_e	Line 2418 instruction_digest(struct_processus *s_e
return;	return;
}	}

if (EVP_DigestUpdate(&contexte, tampon, longueur_tampon) != 1)	if (EVP_DigestUpdate(&contexte, tampon, (size_t) longueur_tampon)
	!= 1)
{	{
free(tampon);	free(tampon);
free(clef);	free(clef);
Line 2455 instruction_digest(struct_processus *s_e	Line 2455 instruction_digest(struct_processus *s_e
clef[i] ^= (0x36 ^ 0x5c);	clef[i] ^= (0x36 ^ 0x5c);
}	}

if ((tampon = malloc((longueur_bloc + longueur_somme) *	if ((tampon = malloc(((size_t) (longueur_bloc + longueur_somme)) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

memcpy(tampon, clef, longueur_bloc);	memcpy(tampon, clef, (size_t) longueur_bloc);
memcpy(tampon + longueur_bloc, somme, longueur_somme);	memcpy(tampon + longueur_bloc, somme, (size_t) longueur_somme);
longueur_tampon = longueur_bloc + longueur_somme;	longueur_tampon = longueur_bloc + longueur_somme;

if (EVP_DigestInit(&contexte, EVP_sum) != 1)	if (EVP_DigestInit(&contexte, EVP_sum) != 1)
Line 2481 instruction_digest(struct_processus *s_e	Line 2481 instruction_digest(struct_processus *s_e
return;	return;
}	}

if (EVP_DigestUpdate(&contexte, tampon, longueur_tampon) != 1)	if (EVP_DigestUpdate(&contexte, tampon, (size_t) longueur_tampon)
	!= 1)
{	{
free(tampon);	free(tampon);
free(clef);	free(clef);

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.45
changed lines
	Added in v.1.55