~cjwatson/ubuntu/precise/openssh/precise-proposed

« back to all changes in this revision

Viewing changes to loginrec.c

  • Committer: Colin Watson
  • Date: 2011-01-24 12:43:25 UTC
  • mfrom: (2660.2.14 gssapi)
  • mto: This revision was merged to the branch mainline in revision 3226.
  • Revision ID: cjwatson@debian.org-20110124124325-lpg368jr1esoeqtt
* New upstream release (http://www.openssh.org/txt/release-5.7):
  - Implement Elliptic Curve Cryptography modes for key exchange (ECDH)
    and host/user keys (ECDSA) as specified by RFC5656.  ECDH and ECDSA
    offer better performance than plain DH and DSA at the same equivalent
    symmetric key length, as well as much shorter keys.
  - sftp(1)/sftp-server(8): add a protocol extension to support a hard
    link operation.  It is available through the "ln" command in the
    client.  The old "ln" behaviour of creating a symlink is available
    using its "-s" option or through the preexisting "symlink" command.
  - scp(1): Add a new -3 option to scp: Copies between two remote hosts
    are transferred through the local host (closes: #508613).
  - ssh(1): "atomically" create the listening mux socket by binding it on
    a temporary name and then linking it into position after listen() has
    succeeded.  This allows the mux clients to determine that the server
    socket is either ready or stale without races (closes: #454784).
    Stale server sockets are now automatically removed (closes: #523250).
  - ssh(1): install a SIGCHLD handler to reap expired child process
    (closes: #594687).
  - ssh(1)/ssh-agent(1): honour $TMPDIR for client xauth and ssh-agent
    temporary directories (closes: #357469, although only if you arrange
    for ssh-agent to actually see $TMPDIR since the setgid bit will cause
    it to be stripped off).

Show diffs side-by-side

added added

removed removed

Lines of Context:
273
273
 *                try to retrieve lastlog information from wtmp/wtmpx.
274
274
 */
275
275
unsigned int
276
 
login_get_lastlog_time(const int uid)
 
276
login_get_lastlog_time(const uid_t uid)
277
277
{
278
278
        struct logininfo li;
279
279
 
297
297
 *  0  on failure (will use OpenSSH's logging facilities for diagnostics)
298
298
 */
299
299
struct logininfo *
300
 
login_get_lastlog(struct logininfo *li, const int uid)
 
300
login_get_lastlog(struct logininfo *li, const uid_t uid)
301
301
{
302
302
        struct passwd *pw;
303
303
 
311
311
         */
312
312
        pw = getpwuid(uid);
313
313
        if (pw == NULL)
314
 
                fatal("%s: Cannot find account for uid %i", __func__, uid);
 
314
                fatal("%s: Cannot find account for uid %ld", __func__,
 
315
                    (long)uid);
315
316
 
316
317
        /* No MIN_SIZEOF here - we absolutely *must not* truncate the
317
318
         * username (XXX - so check for trunc!) */
335
336
 * allocation fails, the program halts.
336
337
 */
337
338
struct
338
 
logininfo *login_alloc_entry(int pid, const char *username,
 
339
logininfo *login_alloc_entry(pid_t pid, const char *username,
339
340
    const char *hostname, const char *line)
340
341
{
341
342
        struct logininfo *newli;
363
364
 * Returns: 1
364
365
 */
365
366
int
366
 
login_init_entry(struct logininfo *li, int pid, const char *username,
 
367
login_init_entry(struct logininfo *li, pid_t pid, const char *username,
367
368
    const char *hostname, const char *line)
368
369
{
369
370
        struct passwd *pw;
468
469
#endif
469
470
#ifdef SSH_AUDIT_EVENTS
470
471
        if (li->type == LTYPE_LOGIN)
471
 
                audit_session_open(li->line);
 
472
                audit_session_open(li);
472
473
        else if (li->type == LTYPE_LOGOUT)
473
 
                audit_session_close(li->line);
 
474
                audit_session_close(li);
474
475
#endif
475
476
        return (0);
476
477
}
872
873
                pos = (off_t)tty * sizeof(struct utmp);
873
874
                if ((ret = lseek(fd, pos, SEEK_SET)) == -1) {
874
875
                        logit("%s: lseek: %s", __func__, strerror(errno));
 
876
                        close(fd);
875
877
                        return (0);
876
878
                }
877
879
                if (ret != pos) {
878
880
                        logit("%s: Couldn't seek to tty %d slot in %s",
879
881
                            __func__, tty, UTMP_FILE);
 
882
                        close(fd);
880
883
                        return (0);
881
884
                }
882
885
                /*
892
895
 
893
896
                if ((ret = lseek(fd, pos, SEEK_SET)) == -1) {
894
897
                        logit("%s: lseek: %s", __func__, strerror(errno));
 
898
                        close(fd);
895
899
                        return (0);
896
900
                }
897
901
                if (ret != pos) {
898
902
                        logit("%s: Couldn't seek to tty %d slot in %s",
899
903
                            __func__, tty, UTMP_FILE);
 
904
                        close(fd);
900
905
                        return (0);
901
906
                }
902
907
                if (atomicio(vwrite, fd, ut, sizeof(*ut)) != sizeof(*ut)) {
903
908
                        logit("%s: error writing %s: %s", __func__,
904
909
                            UTMP_FILE, strerror(errno));
 
910
                        close(fd);
 
911
                        return (0);
905
912
                }
906
913
 
907
914
                close(fd);
1205
1212
                        close (fd);
1206
1213
                        return (0);
1207
1214
                }
1208
 
                if ( wtmp_islogin(li, &ut) ) {
 
1215
                if (wtmp_islogin(li, &ut) ) {
1209
1216
                        found = 1;
1210
1217
                        /*
1211
1218
                         * We've already checked for a time in struct
1496
1503
 
1497
1504
        if (S_ISREG(st.st_mode)) {
1498
1505
                /* find this uid's offset in the lastlog file */
1499
 
                offset = (off_t) ((long)li->uid * sizeof(struct lastlog));
 
1506
                offset = (off_t) ((u_long)li->uid * sizeof(struct lastlog));
1500
1507
 
1501
1508
                if (lseek(*fd, offset, SEEK_SET) != offset) {
1502
1509
                        logit("%s: %s->lseek(): %s", __func__,
1503
1510
                            lastlog_file, strerror(errno));
 
1511
                        close(*fd);
1504
1512
                        return (0);
1505
1513
                }
1506
1514
        }
1672
1680
                    strerror(errno));
1673
1681
                goto out;
1674
1682
        }
1675
 
        if((fst.st_mode & (S_IRWXG | S_IRWXO)) || (fst.st_uid != 0)){
 
1683
        if((fst.st_mode & (S_IXGRP | S_IRWXO)) || (fst.st_uid != 0)){
1676
1684
                logit("Excess permission or bad ownership on file %s",
1677
1685
                    _PATH_BTMP);
1678
1686
                goto out;