cksum.c

abstract rtos

static VOID
md5_cksum_block (VOID * data ,
				 U32 datalen ,
				 U32 totallen ,
				 S32 incomplete ,
				 U32 * results)
{
    U32 a, b, c, d;
    S32 alldone = 0;
	
    a = results[0];
    b = results[1];
    c = results[2];
    d = results[3];
	
    {
		U8 *dp;
		U32 dlen;
		U32 *xp;
		U32 x[64];
		
		dp = (U8 *) data;
		dlen = datalen;
		
		while (dlen) {
			xp = x;
			if (dlen >= 64) {
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp); xp++;
				MD5_GET(*xp, dp);
				dlen -= 64;
			} else {
				AOS_ASSERT(!incomplete);
				switch (dlen >> 2) {
				case 15:
					MD5_GET(*xp, dp); xp++;
				case 14:
					MD5_GET(*xp, dp); xp++;
				case 13:
					MD5_GET(*xp, dp); xp++;
				case 12:
					MD5_GET(*xp, dp); xp++;
				case 11:
					MD5_GET(*xp, dp); xp++;
				case 10:
					MD5_GET(*xp, dp); xp++;
				case 9:
					MD5_GET(*xp, dp); xp++;
				case 8:
					MD5_GET(*xp, dp); xp++;
				case 7:
					MD5_GET(*xp, dp); xp++;
				case 6:
					MD5_GET(*xp, dp); xp++;
				case 5:
					MD5_GET(*xp, dp); xp++;
				case 4:
					MD5_GET(*xp, dp); xp++;
				case 3:
					MD5_GET(*xp, dp); xp++;
				case 2:
					MD5_GET(*xp, dp); xp++;
				case 1:
					MD5_GET(*xp, dp); xp++;
				default:
					break;
				}
				
				switch (dlen & 0x3) {
				case 3:
					*xp = (U32) 0x80000000 | (U32)(*dp++);
					*xp |= (U32)(*dp++) << 8;
					*xp++ |= (U32)(*dp++) << 16;
					break;
				case 2:
					*xp = (U32) 0x800000 | (U32)(*dp++);
					*xp++ |= (U32)(*dp++) << 8;
					break;
				case 1:
					*xp++ = (U32) 0x8000 | (U32)(*dp++);
					break;
				default:
					*xp++ = (U32) 0x80;
					break;
				}
				
				if (xp >= &(x[15])) {
					if (xp == &(x[15])) {
						*xp = 0;
					}
				} else {
					while (xp < &(x[14])) {
						*xp++ = 0;
					}
					*xp++ = (((U32)(totallen)) << 3) & 0xffffffff;
					*xp = (U32)((totallen >> 29) & 0xffffffff);
					alldone = 1;
				}
				dlen = 0;
			}
			
			xp = x;
			
			
			MD5_OP1(a, b, c, d, xp[ 0],  7, 0xd76aa478);	
			MD5_OP1(d, a, b, c, xp[ 1], 12, 0xe8c7b756);	
			MD5_OP1(c, d, a, b, xp[ 2], 17, 0x242070db);	
			MD5_OP1(b, c, d, a, xp[ 3], 22, 0xc1bdceee);	
			MD5_OP1(a, b, c, d, xp[ 4],  7, 0xf57c0faf);	
			MD5_OP1(d, a, b, c, xp[ 5], 12, 0x4787c62a);	
			MD5_OP1(c, d, a, b, xp[ 6], 17, 0xa8304613);	
			MD5_OP1(b, c, d, a, xp[ 7], 22, 0xfd469501);	
			MD5_OP1(a, b, c, d, xp[ 8],  7, 0x698098d8);	
			MD5_OP1(d, a, b, c, xp[ 9], 12, 0x8b44f7af);	
			MD5_OP1(c, d, a, b, xp[10], 17, 0xffff5bb1);	
			MD5_OP1(b, c, d, a, xp[11], 22, 0x895cd7be);	
			MD5_OP1(a, b, c, d, xp[12],  7, 0x6b901122);	
			MD5_OP1(d, a, b, c, xp[13], 12, 0xfd987193);	
			MD5_OP1(c, d, a, b, xp[14], 17, 0xa679438e);	
			MD5_OP1(b, c, d, a, xp[15], 22, 0x49b40821);	
			
			
			MD5_OP2(a, b, c, d, xp[ 1],  5, 0xf61e2562);	
			MD5_OP2(d, a, b, c, xp[ 6],  9, 0xc040b340);	
			MD5_OP2(c, d, a, b, xp[11], 14, 0x265e5a51);	
			MD5_OP2(b, c, d, a, xp[ 0], 20, 0xe9b6c7aa);	
			MD5_OP2(a, b, c, d, xp[ 5],  5, 0xd62f105d);	
			MD5_OP2(d, a, b, c, xp[10],  9, 0x02441453);	
			MD5_OP2(c, d, a, b, xp[15], 14, 0xd8a1e681);	
			MD5_OP2(b, c, d, a, xp[ 4], 20, 0xe7d3fbc8);	
			MD5_OP2(a, b, c, d, xp[ 9],  5, 0x21e1cde6);	
			MD5_OP2(d, a, b, c, xp[14],  9, 0xc33707d6);	
			MD5_OP2(c, d, a, b, xp[ 3], 14, 0xf4d50d87);	
			MD5_OP2(b, c, d, a, xp[ 8], 20, 0x455a14ed);	
			MD5_OP2(a, b, c, d, xp[13],  5, 0xa9e3e905);	
			MD5_OP2(d, a, b, c, xp[ 2],  9, 0xfcefa3f8);	
			MD5_OP2(c, d, a, b, xp[ 7], 14, 0x676f02d9);	
			MD5_OP2(b, c, d, a, xp[12], 20, 0x8d2a4c8a);	
			
			
			MD5_OP3(a, b, c, d, xp[ 5],  4, 0xfffa3942);	
			MD5_OP3(d, a, b, c, xp[ 8], 11, 0x8771f681);	
			MD5_OP3(c, d, a, b, xp[11], 16, 0x6d9d6122);	
			MD5_OP3(b, c, d, a, xp[14], 23, 0xfde5380c);	
			MD5_OP3(a, b, c, d, xp[ 1],  4, 0xa4beea44);	
			MD5_OP3(d, a, b, c, xp[ 4], 11, 0x4bdecfa9);	
			MD5_OP3(c, d, a, b, xp[ 7], 16, 0xf6bb4b60);	
			MD5_OP3(b, c, d, a, xp[10], 23, 0xbebfbc70);	
			MD5_OP3(a, b, c, d, xp[13],  4, 0x289b7ec6);	
			MD5_OP3(d, a, b, c, xp[ 0], 11, 0xeaa127fa);	
			MD5_OP3(c, d, a, b, xp[ 3], 16, 0xd4ef3085);	
			MD5_OP3(b, c, d, a, xp[ 6], 23, 0x04881d05);	
			MD5_OP3(a, b, c, d, xp[ 9],  4, 0xd9d4d039);	
			MD5_OP3(d, a, b, c, xp[12], 11, 0xe6db99e5);	
			MD5_OP3(c, d, a, b, xp[15], 16, 0x1fa27cf8);	
			MD5_OP3(b, c, d, a, xp[ 2], 23, 0xc4ac5665);	
			
			
			MD5_OP4(a, b, c, d, xp[ 0],  6, 0xf4292244);	
			MD5_OP4(d, a, b, c, xp[ 7], 10, 0x432aff97);	
			MD5_OP4(c, d, a, b, xp[14], 15, 0xab9423a7);	
			MD5_OP4(b, c, d, a, xp[ 5], 21, 0xfc93a039);	
			MD5_OP4(a, b, c, d, xp[12],  6, 0x655b59c3);	
			MD5_OP4(d, a, b, c, xp[ 3], 10, 0x8f0ccc92);	
			MD5_OP4(c, d, a, b, xp[10], 15, 0xffeff47d);	
			MD5_OP4(b, c, d, a, xp[ 1], 21, 0x85845dd1);	
			MD5_OP4(a, b, c, d, xp[ 8],  6, 0x6fa87e4f);	
			MD5_OP4(d, a, b, c, xp[15], 10, 0xfe2ce6e0);	
			MD5_OP4(c, d, a, b, xp[ 6], 15, 0xa3014314);	
			MD5_OP4(b, c, d, a, xp[13], 21, 0x4e0811a1);	
			MD5_OP4(a, b, c, d, xp[ 4],  6, 0xf7537e82);	
			MD5_OP4(d, a, b, c, xp[11], 10, 0xbd3af235);	
			MD5_OP4(c, d, a, b, xp[ 2], 15, 0x2ad7d2bb);	
			MD5_OP4(b, c, d, a, xp[ 9], 21, 0xeb86d391);	
			
			a += results[0]; results[0] = a;
			b += results[1]; results[1] = b;
			c += results[2]; results[2] = c;
			d += results[3]; results[3] = d;
	}
    }
	
    if (!incomplete && !alldone) {
		U32 x0, x14, x15;
		
		x14 = (((U32)(totallen)) << 3) & 0xffffffff;
		x15 = (U32)((totallen >> 29) & 0xffffffff);
		
		if (datalen & 0x3f) {
			x0 = 0;
		} else {
			x0 = 0x80;
		}
		
		
		MD5_OP1(a, b, c, d,  x0,  7, 0xd76aa478);	
		MD5_OP1(d, a, b, c,   0, 12, 0xe8c7b756);	
		MD5_OP1(c, d, a, b,   0, 17, 0x242070db);	
		MD5_OP1(b, c, d, a,   0, 22, 0xc1bdceee);	
		MD5_OP1(a, b, c, d,   0,  7, 0xf57c0faf);	
		MD5_OP1(d, a, b, c,   0, 12, 0x4787c62a);	
		MD5_OP1(c, d, a, b,   0, 17, 0xa8304613);	
		MD5_OP1(b, c, d, a,   0, 22, 0xfd469501);	
		MD5_OP1(a, b, c, d,   0,  7, 0x698098d8);	
		MD5_OP1(d, a, b, c,   0, 12, 0x8b44f7af);	
		MD5_OP1(c, d, a, b,   0, 17, 0xffff5bb1);	
		MD5_OP1(b, c, d, a,   0, 22, 0x895cd7be);	
		MD5_OP1(a, b, c, d,   0,  7, 0x6b901122);	
		MD5_OP1(d, a, b, c,   0, 12, 0xfd987193);	
		MD5_OP1(c, d, a, b, x14, 17, 0xa679438e);	
		MD5_OP1(b, c, d, a, x15, 22, 0x49b40821);	
		
		
		MD5_OP2(a, b, c, d,   0,  5, 0xf61e2562);	
		MD5_OP2(d, a, b, c,   0,  9, 0xc040b340);	
		MD5_OP2(c, d, a, b,   0, 14, 0x265e5a51);	
		MD5_OP2(b, c, d, a,  x0, 20, 0xe9b6c7aa);	
		MD5_OP2(a, b, c, d,   0,  5, 0xd62f105d);	
		MD5_OP2(d, a, b, c,   0,  9, 0x02441453);	
		MD5_OP2(c, d, a, b, x15, 14, 0xd8a1e681);	
		MD5_OP2(b, c, d, a,   0, 20, 0xe7d3fbc8);	
		MD5_OP2(a, b, c, d,   0,  5, 0x21e1cde6);	
		MD5_OP2(d, a, b, c, x14,  9, 0xc33707d6);	
		MD5_OP2(c, d, a, b,   0, 14, 0xf4d50d87);	
		MD5_OP2(b, c, d, a,   0, 20, 0x455a14ed);	
		MD5_OP2(a, b, c, d,   0,  5, 0xa9e3e905);	
		MD5_OP2(d, a, b, c,   0,  9, 0xfcefa3f8);	
		MD5_OP2(c, d, a, b,   0, 14, 0x676f02d9);	
		MD5_OP2(b, c, d, a,   0, 20, 0x8d2a4c8a);	
		
		
		MD5_OP3(a, b, c, d,   0,  4, 0xfffa3942);	
		MD5_OP3(d, a, b, c,   0, 11, 0x8771f681);	
		MD5_OP3(c, d, a, b,   0, 16, 0x6d9d6122);	
		MD5_OP3(b, c, d, a, x14, 23, 0xfde5380c);	
		MD5_OP3(a, b, c, d,   0,  4, 0xa4beea44);	
		MD5_OP3(d, a, b, c,   0, 11, 0x4bdecfa9);	
		MD5_OP3(c, d, a, b,   0, 16, 0xf6bb4b60);	
		MD5_OP3(b, c, d, a,   0, 23, 0xbebfbc70);	
		MD5_OP3(a, b, c, d,   0,  4, 0x289b7ec6);	
		MD5_OP3(d, a, b, c,  x0, 11, 0xeaa127fa);	
		MD5_OP3(c, d, a, b,   0, 16, 0xd4ef3085);	
		MD5_OP3(b, c, d, a,   0, 23, 0x04881d05);	
		MD5_OP3(a, b, c, d,   0,  4, 0xd9d4d039);	
		MD5_OP3(d, a, b, c,   0, 11, 0xe6db99e5);	
		MD5_OP3(c, d, a, b, x15, 16, 0x1fa27cf8);	
		MD5_OP3(b, c, d, a,   0, 23, 0xc4ac5665);	
		
		
		MD5_OP4(a, b, c, d,  x0,  6, 0xf4292244);	
		MD5_OP4(d, a, b, c,   0, 10, 0x432aff97);	
		MD5_OP4(c, d, a, b, x14, 15, 0xab9423a7);	
		MD5_OP4(b, c, d, a,   0, 21, 0xfc93a039);	
		MD5_OP4(a, b, c, d,   0,  6, 0x655b59c3);	
		MD5_OP4(d, a, b, c,   0, 10, 0x8f0ccc92);	
		MD5_OP4(c, d, a, b,   0, 15, 0xffeff47d);	
		MD5_OP4(b, c, d, a,   0, 21, 0x85845dd1);	
		MD5_OP4(a, b, c, d,   0,  6, 0x6fa87e4f);	
		MD5_OP4(d, a, b, c, x15, 10, 0xfe2ce6e0);	
		MD5_OP4(c, d, a, b,   0, 15, 0xa3014314);	
		MD5_OP4(b, c, d, a,   0, 21, 0x4e0811a1);	
		MD5_OP4(a, b, c, d,   0,  6, 0xf7537e82);	
		MD5_OP4(d, a, b, c,   0, 10, 0xbd3af235);	
		MD5_OP4(c, d, a, b,   0, 15, 0x2ad7d2bb);	
		MD5_OP4(b, c, d, a,   0, 21, 0xeb86d391);	
		
		results[0] += a;
		results[1] += b;
		results[2] += c;
		results[3] += d;
    }
}


U32
md5_cksum_partial (VOID * data ,
				   VOID * upto ,
				   S32 newdata ,
				   U32 * results)
{
    U32 dolen;
	
    if (newdata) {
		results[0] = MD5_A_INIT;
		results[1] = MD5_B_INIT;
		results[2] = MD5_C_INIT;
		results[3] = MD5_D_INIT;
    }
	
    dolen = ((U8 *) upto - (U8 *) data) & (~((U32) 0x3f));
    if (dolen) {
		md5_cksum_block(data, dolen, (U32) 0, 1, results);
    }
	
    return dolen;
}


VOID
MD5_Cksum (VOID * data ,
		   U32 datalen ,
		   U32 totallen ,
		   VOID * digest ,
		   U32 * init)
{
    U8 *dp;
    U32 *tp;
    U32 temp[4];
	
    tp = temp;
    if (init) {
		tp[0] = init[0];
		tp[1] = init[1];
		tp[2] = init[2];
		tp[3] = init[3];
    } else {
		tp[0] = MD5_A_INIT;
		tp[1] = MD5_B_INIT;
		tp[2] = MD5_C_INIT;
		tp[3] = MD5_D_INIT;
    }
	
    md5_cksum_block(data, datalen, totallen, 0, temp);
	
    dp = (U8 *) digest;
    MD5_PUT(*tp, dp); tp++;
    MD5_PUT(*tp, dp); tp++;
    MD5_PUT(*tp, dp); tp++;
    MD5_PUT(*tp, dp);
}
#endif	

#ifdef __cplusplus
#if __cplusplus
}
#endif 
#endif