if (utmp_data->loc_utmp < sizeof (struct utmp))
if (utmp_data->loc_utmp < (off_t) sizeof (struct utmp))
pututline_r (const struct utmp *id, struct utmp_data *utmp_data){  struct stat st;  int result = 0;#if _HAVE_UT_TYPE - 0  /* Test whether ID has any of the legal types because we have to     prevent illegal entries.  */  if (id->ut_type != RUN_LVL && id->ut_type != BOOT_TIME      && id->ut_type != OLD_TIME && id->ut_type != NEW_TIME      && id->ut_type != INIT_PROCESS && id->ut_type != LOGIN_PROCESS      && id->ut_type != USER_PROCESS && id->ut_type != DEAD_PROCESS)    /* No, using '<' and '>' for the test is not possible.  */    {      errno = EINVAL;      return -1;    }#endif  /* Open utmp file if not already done.  */  if (utmp_data->ut_fd == -1)    {      setutent_r (utmp_data);      if (utmp_data->ut_fd == -1)	return -1;    }#if _HAVE_UT_TYPE - 0  /* Seek position to write.  */  if (utmp_data->loc_utmp >= sizeof (struct utmp)      && utmp_data->ubuf.ut_type != id->ut_type)    {      /* We must not overwrite the data in UTMP_DATA.  */      struct utmp_data *data_tmp = alloca (sizeof (*data_tmp));      struct utmp *dummy;      *data_tmp = *utmp_data;      utmp_data = data_tmp;      if (getutid_r (id, &dummy, utmp_data) < 0)	{	  if (errno != ESRCH)	    /* Some error occured.  If no entry was found, the position	       pointer now is at the end of the file.  */	    return -1;	  /* Set position pointer to position after adding of the record.  */	  utmp_data->loc_utmp += sizeof (struct utmp);	}    }#endif  /* Try to lock the file.  */  if (flock (utmp_data->ut_fd, LOCK_EX | LOCK_NB) < 0 && errno != ENOSYS)    {      /* Oh, oh.  The file is already locked.  Wait a bit and try again.  */      sleep (1);      /* This time we ignore the error.  */      (void) flock (utmp_data->ut_fd, LOCK_EX | LOCK_NB);    }  /* Find out how large the file is.  */  result = fstat (utmp_data->ut_fd, &st);  if (result >= 0)    /* Position file correctly.  */    if (utmp_data->loc_utmp < sizeof (struct utmp))      /* Not located at any valid entry.  Add at the end.  */      {	result = lseek (utmp_data->ut_fd, 0L, SEEK_END);	if (result >= 0)	  /* Where we'll be if the write succeeds.  */	  utmp_data->loc_utmp = st.st_size + sizeof (struct utmp);      }    else if (utmp_data->loc_utmp <= st.st_size)      result =	lseek (utmp_data->ut_fd, utmp_data->loc_utmp - sizeof (struct utmp),	       SEEK_SET);  if (result >= 0)    /* Write the new data.  */    if (write (utmp_data->ut_fd, id, sizeof (struct utmp))	!= sizeof (struct utmp))      {	/* If we appended a new record this is only partially written.	   Remove it.  */	if (utmp_data->loc_utmp > st.st_size)	  {	    (void) ftruncate (utmp_data->ut_fd, st.st_size);	    utmp_data->loc_utmp = st.st_size;	  }	result = -1;      }  /* And unlock the file.  */  (void) flock (utmp_data->ut_fd, LOCK_UN);  return result;}