* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- * must display the following acknowledgement:
- * This product includes software developed by Markus Friedl.
- * 4. The name of the author may not be used to endorse or promote products
- * derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
{
#ifndef HAVE_CYGWIN
if ((int)geteuid() != 0) {
- log("Attempt to write login records by non-root user (aborting)");
+ logit("Attempt to write login records by non-root user (aborting)");
return 1;
}
#endif
#endif
#ifdef USE_WTMPX
wtmpx_write_entry(li);
+#endif
+#ifdef CUSTOM_SYS_AUTH_RECORD_LOGIN
+ if (li->type == LTYPE_LOGIN &&
+ !sys_auth_record_login(li->username,li->hostname,li->line))
+ logit("Writing login record failed for %s", li->username);
#endif
return 0;
}
int
login_utmp_only(struct logininfo *li)
{
- li->type = LTYPE_LOGIN;
+ li->type = LTYPE_LOGIN;
login_set_current_time(li);
# ifdef USE_UTMP
utmp_write_entry(li);
construct_utmp(struct logininfo *li,
struct utmp *ut)
{
+# ifdef HAVE_ADDR_V6_IN_UTMP
+ struct sockaddr_in6 *sa6;
+# endif
memset(ut, '\0', sizeof(*ut));
/* First fill out fields used for both logins and logouts */
switch (li->type) {
case LTYPE_LOGIN:
ut->ut_type = USER_PROCESS;
-#ifdef _CRAY
+#ifdef _UNICOS
cray_set_tmpdir(ut);
#endif
break;
case LTYPE_LOGOUT:
ut->ut_type = DEAD_PROCESS;
-#ifdef _CRAY
+#ifdef _UNICOS
cray_retain_utmp(ut, li->pid);
#endif
break;
if (li->hostaddr.sa.sa_family == AF_INET)
ut->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
# endif
+# ifdef HAVE_ADDR_V6_IN_UTMP
+ /* this is just a 128-bit IPv6 address */
+ if (li->hostaddr.sa.sa_family == AF_INET6) {
+ sa6 = ((struct sockaddr_in6 *)&li->hostaddr.sa);
+ memcpy(ut->ut_addr_v6, sa6->sin6_addr.s6_addr, 16);
+ if (IN6_IS_ADDR_V4MAPPED(&sa6->sin6_addr)) {
+ ut->ut_addr_v6[0] = ut->ut_addr_v6[3];
+ ut->ut_addr_v6[1] = 0;
+ ut->ut_addr_v6[2] = 0;
+ ut->ut_addr_v6[3] = 0;
+ }
+ }
+# endif
}
#endif /* USE_UTMP || USE_WTMP || USE_LOGIN */
void
construct_utmpx(struct logininfo *li, struct utmpx *utx)
{
+# ifdef HAVE_ADDR_V6_IN_UTMP
+ struct sockaddr_in6 *sa6;
+# endif
memset(utx, '\0', sizeof(*utx));
# ifdef HAVE_ID_IN_UTMPX
line_abbrevname(utx->ut_id, li->line, sizeof(utx->ut_id));
if (li->hostaddr.sa.sa_family == AF_INET)
utx->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
# endif
+# ifdef HAVE_ADDR_V6_IN_UTMP
+ /* this is just a 128-bit IPv6 address */
+ if (li->hostaddr.sa.sa_family == AF_INET6) {
+ sa6 = ((struct sockaddr_in6 *)&li->hostaddr.sa);
+ memcpy(ut->ut_addr_v6, sa6->sin6_addr.s6_addr, 16);
+ if (IN6_IS_ADDR_V4MAPPED(&sa6->sin6_addr)) {
+ ut->ut_addr_v6[0] = ut->ut_addr_v6[3];
+ ut->ut_addr_v6[1] = 0;
+ ut->ut_addr_v6[2] = 0;
+ ut->ut_addr_v6[3] = 0;
+ }
+ }
+# endif
# ifdef HAVE_SYSLEN_IN_UTMPX
/* ut_syslen is the length of the utx_host string */
utx->ut_syslen = MIN(strlen(li->hostname), sizeof(utx->ut_host));
endttyent();
if((struct ttyent *)0 == ty) {
- log("utmp_write_entry: tty not found");
+ logit("utmp_write_entry: tty not found");
return(1);
}
#else /* FIXME */
}
(void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
- if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut))
- log("utmp_write_direct: error writing %s: %s",
+ if (atomicio(vwrite, fd, ut, sizeof(*ut)) != sizeof(*ut))
+ logit("utmp_write_direct: error writing %s: %s",
UTMP_FILE, strerror(errno));
(void)close(fd);
construct_utmp(li, &ut);
# ifdef UTMP_USE_LIBRARY
if (!utmp_write_library(li, &ut)) {
- log("utmp_perform_login: utmp_write_library() failed");
+ logit("utmp_perform_login: utmp_write_library() failed");
return 0;
}
# else
if (!utmp_write_direct(li, &ut)) {
- log("utmp_perform_login: utmp_write_direct() failed");
+ logit("utmp_perform_login: utmp_write_direct() failed");
return 0;
}
# endif
construct_utmp(li, &ut);
# ifdef UTMP_USE_LIBRARY
if (!utmp_write_library(li, &ut)) {
- log("utmp_perform_logout: utmp_write_library() failed");
+ logit("utmp_perform_logout: utmp_write_library() failed");
return 0;
}
# else
if (!utmp_write_direct(li, &ut)) {
- log("utmp_perform_logout: utmp_write_direct() failed");
+ logit("utmp_perform_logout: utmp_write_direct() failed");
return 0;
}
# endif
return utmp_perform_logout(li);
default:
- log("utmp_write_entry: invalid type field");
+ logit("utmp_write_entry: invalid type field");
return 0;
}
}
static int
utmpx_write_direct(struct logininfo *li, struct utmpx *utx)
{
- log("utmpx_write_direct: not implemented!");
+ logit("utmpx_write_direct: not implemented!");
return 0;
}
# endif /* UTMPX_USE_LIBRARY */
construct_utmpx(li, &utx);
# ifdef UTMPX_USE_LIBRARY
if (!utmpx_write_library(li, &utx)) {
- log("utmpx_perform_login: utmp_write_library() failed");
+ logit("utmpx_perform_login: utmp_write_library() failed");
return 0;
}
# else
if (!utmpx_write_direct(li, &ut)) {
- log("utmpx_perform_login: utmp_write_direct() failed");
+ logit("utmpx_perform_login: utmp_write_direct() failed");
return 0;
}
# endif
case LTYPE_LOGOUT:
return utmpx_perform_logout(li);
default:
- log("utmpx_write_entry: invalid type field");
+ logit("utmpx_write_entry: invalid type field");
return 0;
}
}
int fd, ret = 1;
if ((fd = open(WTMP_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
- log("wtmp_write: problem writing %s: %s",
+ logit("wtmp_write: problem writing %s: %s",
WTMP_FILE, strerror(errno));
return 0;
}
if (fstat(fd, &buf) == 0)
- if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut)) {
+ if (atomicio(vwrite, fd, ut, sizeof(*ut)) != sizeof(*ut)) {
ftruncate(fd, buf.st_size);
- log("wtmp_write: problem writing %s: %s",
+ logit("wtmp_write: problem writing %s: %s",
WTMP_FILE, strerror(errno));
ret = 0;
}
case LTYPE_LOGOUT:
return wtmp_perform_logout(li);
default:
- log("wtmp_write_entry: invalid type field");
+ logit("wtmp_write_entry: invalid type field");
return 0;
}
}
li->tv_sec = li->tv_usec = 0;
if ((fd = open(WTMP_FILE, O_RDONLY)) < 0) {
- log("wtmp_get_entry: problem opening %s: %s",
+ logit("wtmp_get_entry: problem opening %s: %s",
WTMP_FILE, strerror(errno));
return 0;
}
if (fstat(fd, &st) != 0) {
- log("wtmp_get_entry: couldn't stat %s: %s",
+ logit("wtmp_get_entry: couldn't stat %s: %s",
WTMP_FILE, strerror(errno));
close(fd);
return 0;
while (!found) {
if (atomicio(read, fd, &ut, sizeof(ut)) != sizeof(ut)) {
- log("wtmp_get_entry: read of %s failed: %s",
+ logit("wtmp_get_entry: read of %s failed: %s",
WTMP_FILE, strerror(errno));
close (fd);
return 0;
static int
wtmpx_write(struct logininfo *li, struct utmpx *utx)
{
+#ifndef HAVE_UPDWTMPX
struct stat buf;
int fd, ret = 1;
if ((fd = open(WTMPX_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
- log("wtmpx_write: problem opening %s: %s",
+ logit("wtmpx_write: problem opening %s: %s",
WTMPX_FILE, strerror(errno));
return 0;
}
if (fstat(fd, &buf) == 0)
- if (atomicio(write, fd, utx, sizeof(*utx)) != sizeof(*utx)) {
+ if (atomicio(vwrite, fd, utx, sizeof(*utx)) != sizeof(*utx)) {
ftruncate(fd, buf.st_size);
- log("wtmpx_write: problem writing %s: %s",
+ logit("wtmpx_write: problem writing %s: %s",
WTMPX_FILE, strerror(errno));
ret = 0;
}
(void)close(fd);
return ret;
+#else
+ updwtmpx(WTMPX_FILE, utx);
+ return 1;
+#endif
}
case LTYPE_LOGOUT:
return wtmpx_perform_logout(li);
default:
- log("wtmpx_write_entry: invalid type field");
+ logit("wtmpx_write_entry: invalid type field");
return 0;
}
}
li->tv_sec = li->tv_usec = 0;
if ((fd = open(WTMPX_FILE, O_RDONLY)) < 0) {
- log("wtmpx_get_entry: problem opening %s: %s",
+ logit("wtmpx_get_entry: problem opening %s: %s",
WTMPX_FILE, strerror(errno));
return 0;
}
if (fstat(fd, &st) != 0) {
- log("wtmpx_get_entry: couldn't stat %s: %s",
+ logit("wtmpx_get_entry: couldn't stat %s: %s",
WTMPX_FILE, strerror(errno));
close(fd);
return 0;
while (!found) {
if (atomicio(read, fd, &utx, sizeof(utx)) != sizeof(utx)) {
- log("wtmpx_get_entry: read of %s failed: %s",
+ logit("wtmpx_get_entry: read of %s failed: %s",
WTMPX_FILE, strerror(errno));
close (fd);
return 0;
struct utmp *ut;
if (! (ut = (struct utmp *)malloc(sizeof(*ut)))) {
- log("syslogin_perform_login: couldn't malloc()");
+ logit("syslogin_perform_login: couldn't malloc()");
return 0;
}
construct_utmp(li, ut);
login(ut);
+ free(ut);
return 1;
}
syslogin_perform_logout(struct logininfo *li)
{
# ifdef HAVE_LOGOUT
- char line[8];
+ char line[UT_LINESIZE];
(void)line_stripname(line, li->line, sizeof(line));
if (!logout(line)) {
- log("syslogin_perform_logout: logout() returned an error");
+ logit("syslogin_perform_logout: logout() returned an error");
# ifdef HAVE_LOGWTMP
} else {
logwtmp(line, "", "");
case LTYPE_LOGOUT:
return syslogin_perform_logout(li);
default:
- log("syslogin_write_entry: Invalid type field");
+ logit("syslogin_write_entry: Invalid type field");
return 0;
}
}
struct stat st;
if (stat(LASTLOG_FILE, &st) != 0) {
- log("lastlog_perform_login: Couldn't stat %s: %s", LASTLOG_FILE,
+ logit("lastlog_perform_login: Couldn't stat %s: %s", LASTLOG_FILE,
strerror(errno));
return 0;
}
LASTLOG_FILE, li->username);
break;
default:
- log("lastlog_openseek: %.100s is not a file or directory!",
+ logit("lastlog_openseek: %.100s is not a file or directory!",
LASTLOG_FILE);
return 0;
}
- *fd = open(lastlog_file, filemode);
+ *fd = open(lastlog_file, filemode, 0600);
if ( *fd < 0) {
debug("lastlog_openseek: Couldn't open %s: %s",
lastlog_file, strerror(errno));
offset = (off_t) ((long)li->uid * sizeof(struct lastlog));
if ( lseek(*fd, offset, SEEK_SET) != offset ) {
- log("lastlog_openseek: %s->lseek(): %s",
+ logit("lastlog_openseek: %s->lseek(): %s",
lastlog_file, strerror(errno));
return 0;
}
return(0);
/* write the entry */
- if (atomicio(write, fd, &last, sizeof(last)) != sizeof(last)) {
+ if (atomicio(vwrite, fd, &last, sizeof(last)) != sizeof(last)) {
close(fd);
- log("lastlog_write_filemode: Error writing to %s: %s",
+ logit("lastlog_write_filemode: Error writing to %s: %s",
LASTLOG_FILE, strerror(errno));
return 0;
}
case LTYPE_LOGIN:
return lastlog_perform_login(li);
default:
- log("lastlog_write_entry: Invalid type field");
+ logit("lastlog_write_entry: Invalid type field");
return 0;
}
}
lastlog_get_entry(struct logininfo *li)
{
struct lastlog last;
- int fd;
+ int fd, ret;
if (!lastlog_openseek(li, &fd, O_RDONLY))
- return 0;
-
- if (atomicio(read, fd, &last, sizeof(last)) != sizeof(last)) {
- close(fd);
- log("lastlog_get_entry: Error reading from %s: %s",
- LASTLOG_FILE, strerror(errno));
- return 0;
- }
+ return (0);
+ ret = atomicio(read, fd, &last, sizeof(last));
close(fd);
- lastlog_populate_entry(li, &last);
+ switch (ret) {
+ case 0:
+ memset(&last, '\0', sizeof(last));
+ /* FALLTHRU */
+ case sizeof(last):
+ lastlog_populate_entry(li, &last);
+ return (1);
+ case -1:
+ error("%s: Error reading from %s: %s", __func__,
+ LASTLOG_FILE, strerror(errno));
+ return (0);
+ default:
+ error("%s: Error reading from %s: Expecting %d, got %d",
+ __func__, LASTLOG_FILE, sizeof(last), ret);
+ return (0);
+ }
- return 1;
+ /* NOTREACHED */
+ return (0);
}
#endif /* USE_LASTLOG */
andersk / openssh.git / blobdiff