Can't spot the problem with this.. (novice...

...
What the problem is, is that the modulus operator has an implied division.
If the input value is zero, then all bets are off. Try something like one of
these:

/* Recursive: Simple, eh? */
unsigned
gcd1 (unsigned i, unsigned j)
{
return j ? gcd1 (j, i % j) : i;

/* Iterative: Still a snap */
unsigned
gcd2 (unsigned i, unsigned j)
{
while (j)
{
unsigned t = j;
j = i % j;
i = t;
}
return i;

/*
** A teensy bit more complicated, but worth the bother:
*/

//
/* This function uses the Euclidean Algorithm to */
/* calculate the greatest common divisor of two */
/* unsigned long integers. */
//
/* Programmer: Danniel R. Corbit */
/* */
/* Copyright (C) 1992 by Danniel R. Corbit */
/* All rights reserved. */
//
/* Reference: "Factorization and Primality Testing", */
/* by David M. Bressoud, */
/* Springer-Verlag 1989. */
/* pages 7-12. */
//
unsigned long
gcd (unsigned long a, unsigned long b)
{
int shiftcount = 0;
unsigned long tmp;

//
/* This zero testing stuff may seem odd, since zero is not likely. */
/* However, knowing that neither a nor b is zero will speed up */
/* later operations greatly by elimination of tests for zero. */
//
if (a == 0L)
{
tmp = b;
}
else if (b == 0L)
{
tmp = a;
}
else
{ /* Neither a NOR b is zero! */
//
/* While all this fuss about numbers divisible by 2 may seem */
/* like quite a bother, half of the integers in the universe */
/* are evenly divisible by 2. Hence, on a random sample of */
/* input values, great benefit will be realized. The odds */
/* that at least one of a,b is even is 1 - (1/2)*(1/2) = .75 */
/* since the probability that both are odd is .25. */
//
/* If the last bit is 0, the number is divisible by 2 evenly. */
/* If a & b are divisible by 2, gcd(a,b) = 2*gcd(a/2,b/2). */
//
while (!(a & 1L) && !(b & 1L))
{
a b shiftcount++;
}

//
/* If a is divisible by 2 and b is not divisible by 2, */
/* then gcd(a,b) = gcd(a/2,b). */
//
while (!(a & 1L))
{
a }

//
/* If b is divisible by 2 and a is not divisible by 2, */
/* then gcd(a,b) = gcd(a,b/2). */
//
while (!(b & 1L))
{
b }

//
/* Make sure the numbers are in the proper order (swap if necessary). */
//
if (b {
tmp = a;
a = b;
b = tmp;
}
//
/* Euclid's famous gcd algorithm: */
/* Iterate until the remainder is <= 1. */
//
while (b {
tmp = b;
b = a % b;
a = tmp;
}
if (b == 0)
tmp = a;
else
tmp = b;

//
/* If we divided BOTH numbers by factors of 2, we must compensate. */
//
if (shiftcount tmp <<= shiftcount;
}
return (tmp);
--
C-FAQ: #
"The C-FAQ Book" ISBN 0-201-84519-9
C.A.P. Newsgroup #
C.A.P. FAQ: #

Did you leave out a test there, sparky?
C:\tmp
C:\tmp PC-lint for C/C++ (NT) Ver. 7.00p, Copyright Gimpel Software 1985-1997
--- Module: foo.c

C:\tmp
--- Module: foo.c
_
if (a % i == 0 && b % i == 0)
foo.c(25) : Warning 414: Possible division by 0
foo.c(25) : Warning 414: Possible division by 0
--
C-FAQ: #
"The C-FAQ Book" ISBN 0-201-84519-9
C.A.P. Newsgroup #
C.A.P. FAQ: #