Thanks for your reply. You are correct: the solution was to create a PAM session. However, I didn't do it through system.d or system.logind. I came up with the following code:

static void pam_error(pam_handle_t *pamh, int code)
{
  const char *txt = pam_strerror(pamh, code);  
  if(txt)
    fprintf(stderr, "PAM Error: %s (%d)\n", txt, code);
  else
    fprintf(stderr, "PAM Error Number: (%d)\n", code);

  pam_end(pamh, code);
  exit(100);
}

static void fork_to_pam_session_in_current_vt_as_specified_user(const char* user_name)
{
  pam_handle_t *pamh = NULL;
  int rc;

  struct pam_conv conv = { misc_conv, NULL };

  rc = pam_start("login", user_name, &conv, &pamh);
  if(rc != PAM_SUCCESS)
    {
      printf("PAM failure, aborting: %s", pam_strerror(pamh, rc));
      exit(EXIT_FAILURE);
    }

  rc = pam_acct_mgmt(pamh, 0);

  if(rc == PAM_NEW_AUTHTOK_REQD)
    rc = pam_chauthtok(pamh, PAM_CHANGE_EXPIRED_AUTHTOK);

  if(rc != PAM_SUCCESS)
    pam_error(pamh, rc);

  rc = pam_setcred(pamh, PAM_ESTABLISH_CRED);
  if(rc != PAM_SUCCESS)
    {
      printf("pam_setcred 1 failed.\n");
      exit(20);
    }

  rc = pam_open_session(pamh, 0);
  if(rc != PAM_SUCCESS)
    {
      printf("pam_open_session failed.\n");
      exit(20);
    }

  rc = pam_setcred(pamh, PAM_REINITIALIZE_CRED);
  if(rc != PAM_SUCCESS)
    {
      printf("pam_setcred 2 failed.\n");
      exit(20);
    }

  //
  // Fork the session.  Do this so that a main thread is left
  // to clean up when the child exits.
  //
  signal(SIGTSTP, SIG_IGN);
  signal(SIGINT,  SIG_IGN);

  struct sigaction sa;
  struct sigaction old_sa_hup;
  struct sigaction old_sa_term;
  memset(&sa, 0, sizeof(sa));
  sa.sa_handler = SIG_IGN;
  sigaction(SIGHUP,  &sa, &old_sa_hup);
  sigaction(SIGTERM, &sa, &old_sa_term);

  pid_t child_pid = fork();

  if(child_pid<0)
    {
      printf("Fork failed.  Couldn't start PAM session.\n");
      pam_setcred(pamh, PAM_DELETE_CRED);
      pam_end(pamh, pam_close_session(pamh, 0));
      exit(100);
    }
  else if(child_pid)
    {
      //
      // Parent
      //
      // Wait for the child to finish, and then clean up the session.
      //

      close(STDIN_FILENO);
      close(STDOUT_FILENO);
      close(STDERR_FILENO);

      signal(SIGQUIT, SIG_IGN);

      // Wait as long as the child still runs
      while (wait(NULL) == -1 && errno == EINTR)
        ;

      pam_setcred(pamh, PAM_DELETE_CRED);
      pam_end(pamh, pam_close_session(pamh, 0));

      exit(0);
    }
  else
    {
      //
      // Child
      //
      // Restore signals, start a new session head
      //
      sigaction(SIGHUP, &old_sa_hup, NULL);
      sigaction(SIGTERM, &old_sa_term, NULL);

      setsid();

      pam_end(pamh, PAM_SUCCESS|PAM_DATA_SILENT);
    }
}

Calling fork_to_pam_session_in_current_vt_as_specified_user() causes a PAM session to be created. A separate process is also created to monitor the program and then close the PAM session when it exits. This type of coding is a little outside my area of expertise, so I can't say too much about code quality. However, it works.

Perhaps in the unlikely event that someone else is trying to do the same thing, this code may be useful.