• search is our own simplied implementation of the find built-in.
• The following main relies on listMatches, which we'll implement a little later. (The full program of interest is online right here.)

static void exitUnless(bool test, FILE *stream, int code, const char *control, ...) {
  if (test) return;
  va_list arglist;
  va_start(arglist, control);
  vfprintf(stream, control, arglist);
  va_end(arglist);
  exit(code);
}

int main(int argc, char *argv[]) {
  exitUnless(argc == 3, stderr, kWrongArgumentCount,
             "Usage: %s <directory> <pattern>\n", argv[0]);
  struct stat st;
  const char *directory = argv[1];
  stat(directory, &st);
  exitUnless(S_ISDIR(st.st_mode), stderr, kDirectoryNeeded,
             "<directory> must be an actual directory, %s is not", directory);
  size_t length = strlen(directory);
  if (length > kMaxPath) return 0;

  const char *pattern = argv[2];
  char path[kMaxPath + 1];
  strcpy(path, directory); // no buffer overflow because of above check                  
  listMatches(path, length, pattern);
  return 0;
}

• Don't worry about the va_list trickery unless you're curious. I just wanted to unify error checking to a single helper function. My exitUnless is basically a sexier version of the assert macro.
• The first thing that's new to us is the call to stat, which lifts a bunch of information about the named file off of the file system and populates st with it.
• You'll also note the use of the S_ISDIR macro, which examines the upper four bits of the st_mode field to determine whether the named file is a directory (or a link to one).
• S_ISDIR has a few cousins: S_ISREG decides whether a file is a regular file, and S_ISLNK decided whether the file is a link. (We'll use all of these in our next example).
• Most of what's interesting is managed by the listMatches function, which does a depth-first traversal of the file system to see what files just happen to contain a named pattern as a substring.

Implementation of listMatches

static void listMatches(char path[], size_t length, const char *pattern) {
  DIR *dir = opendir(path);
  if (dir == NULL) return; // path isn't a directory
  strcpy(path + length, "/");
  while (true) {
    struct dirent *de = readdir(dir);
    if (de == NULL) break;
    if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
    if (length + strlen(de->d_name) + 1 > kMaxPath) continue;
    strcpy(path + length + 1, de->d_name);
    struct stat st;
    lstat(path, &st);
    if (S_ISREG(st.st_mode)) { 
      if (strstr(de->d_name, pattern) != NULL) {
        printf("%s\n", path);
      }
    } else if (S_ISDIR(st.st_mode)) {
      listMatches(path, length + 1 + strlen(de->d_name), pattern);
    }
  }

  closedir(dir);
}

• My implementation relies on opendir, which accepts what is presumably a directory. It returns a pointer to an opaque iterable that surfaces a sequence of struct dirents via a series of readdir calls.
• If opendir's parameter is something other than a directory, it'll return NULL.
• When the DIR has surfaced all of its entries, readdir returns NULL. A return value of NULL says it's all over.
• The struct dirent is only guaranteed to contain a d_name field, which is a C string expression of the directory entry's name. . and .. are among the sequence of named entries, but I ignore them so I don't cycle through any single directory more than once.
• I use lstat instead of stat so I know whether an entry is really a link.
• If the status clearly identifies an entry as a regular file, then I print the entire path if and only if it contains the pattern of interest.
• If the status identifies an entry to be a directory, then I recursively descend into it to see if any of its named entries match the pattern we're looking for.
• opendir returns access to a record that eventually must be released via a call to closedir. That's why my implementation ends with it.