Attachment #25428 for bug #40859

View | Details | Raw Unified | Return to bug 40859
Collapse All | Expand All




    f = fopen (gconfig.authfile, "r");
    if (!f)
    {
        _log (LOG_WARN, "%s : Unable to open '%s' for authentication\n",
             __FUNCTION__, gconfig.authfile);
        return 0;
    }

        /* us */
        if (!*u)
        {
            _log (LOG_WARN,
                 "%s: Invalid authentication info (no us), line %d\n",
                 __FUNCTION__, num);
            continue;

        /* them */
        if (!*t)
        {
            _log (LOG_WARN,
                 "%s: Invalid authentication info (nothem), line %d\n",
                 __FUNCTION__, num);
            continue;

            s++;
        if (!*s)
        {
            _log (LOG_WARN,
                 "%s: Invalid authentication info (no secret), line %d\n",
                 __FUNCTION__, num);
            continue;

            (!strcasecmp (t, them) || !strcasecmp (t, "*")))
        {
#ifdef DEBUG_AUTH
            _log (LOG_DEBUG,
                 "%s: we are '%s', they are '%s', secret is '%s'\n",
                 __FUNCTION__, u, t, s);
#endif

    char *them;
    if (!t->lns && !t->lac)
    {
        _log (LOG_DEBUG, "%s: No LNS or LAC to handle challenge!\n",
             __FUNCTION__);
        return -1;
    }
#ifdef DEBUG_AUTH
    _log (LOG_DEBUG, "%s: making response for tunnel: %d\n", __FUNCTION__,
         t->ourtid);
#endif
    if (t->lns)

    }
    if (!get_secret (us, them, chal->secret, sizeof (chal->secret)))
    {
        _log (LOG_DEBUG, "%s: no secret found for us='%s' and them='%s'\n",
             __FUNCTION__, us, them);
        return -1;
    }

#if DEBUG_AUTH
    _log (LOG_DEBUG, "*%s: Here comes the chal->ss:\n", __FUNCTION__);
    bufferDump (&chal->ss, 1);

    _log (LOG_DEBUG, "%s: Here comes the secret\n", __FUNCTION__);
    bufferDump (chal->secret, strlen (chal->secret));

    _log (LOG_DEBUG, "%s: Here comes the challenge\n", __FUNCTION__);
    bufferDump (chal->challenge, strlen (chal->challenge));
#endif


    MD5Update (&chal->md5, chal->challenge, strlen(chal->challenge));
    MD5Final (chal->response, &chal->md5);
#ifdef DEBUG_AUTH
    _log (LOG_DEBUG, "response is %X%X%X%X to '%s' and %X%X%X%X, %d\n",
         *((int *) &chal->response[0]),
         *((int *) &chal->response[4]),
         *((int *) &chal->response[8]),

                (ntohl (t->peer.sin_addr.s_addr) <= ntohl (ipr->end)))
            {
#ifdef DEBUG_AAA
                _log (LOG_DEBUG,
                     "get_lns: Rule %s to %s, sense %s matched %s\n",
                     IPADDY (ipr->start), IPADDY (ipr->end),
                     (ipr->sense ? "allow" : "deny"), IPADDY (t->addr));

void print_md5 (void *md5)
{
    int *i = (int *) md5;
    _log (LOG_DEBUG, "%X%X%X%X\n", i[0], i[1], i[2], i[3], i[4]);
}

inline void print_challenge (struct challenge *chal)
{
    _log (LOG_DEBUG, "vector: ");
    print_md5 (chal->vector);
    _log (LOG_DEBUG, "secret: %s\n", chal->secret);
}
#endif
void encrypt_avp (struct buffer *buf, _u16 len, struct tunnel *t)

    while (ptr < end)
    {
#if DEBUG_HIDDEN
        _log (LOG_DEBUG, "%s: The digest to be XOR'ed\n", __FUNCTION__);
        bufferDump (digest, MD_SIG_SIZE);
        _log (LOG_DEBUG, "%s: The plaintext to be XOR'ed\n", __FUNCTION__);
        bufferDump (ptr, MD_SIG_SIZE);
#endif
        for (cnt = 0; cnt < MD_SIG_SIZE; cnt++, ptr++)

            *ptr = *ptr ^ digest[cnt];
        }
#if DEBUG_HIDDEN
        _log (LOG_DEBUG, "%s: The result of XOR\n", __FUNCTION__);
        bufferDump (previous_segment, MD_SIG_SIZE);
#endif
        if (ptr < end)

    end = buf + olen;
    if (!t->chal_us.vector)
    {
        _log (LOG_DEBUG,
             "decrypt_avp: Hidden bit set, but no random vector specified!\n");
        return -EINVAL;
    }

    MD5Update (&t->chal_us.md5, t->chal_us.vector, t->chal_us.vector_len);
    MD5Final (digest, &t->chal_us.md5);
#ifdef DEBUG_HIDDEN
    _log (LOG_DEBUG, "attribute is %d and challenge is: ", attr);
    print_challenge (&t->chal_us);
    _log (LOG_DEBUG, "md5 is: ");
    print_md5 (digest);
#endif
    while (ptr < end)

    len = ntohs (new_hdr->attr) + sizeof (struct avp_hdr);
    if (len > olen - 2)
    {
        _log (LOG_DEBUG,
             "decrypt_avp: Decrypted length is too long (%d > %d)\n", len,
             olen - 2);
        return -EINVAL;




    if (datalen != 8)
    {
        if (DEBUG)
            _log (LOG_DEBUG, "%s: wrong size (%d != 8)\n", __FUNCTION__,
                 datalen);
        wrong_length (c, "Message Type", 8, datalen, 0);
        return -EINVAL;

    if ((c->msgtype > MAX_MSG) || (!msgtypes[c->msgtype]))
    {
        if (DEBUG)
            _log (LOG_DEBUG, "%s: unknown message type %d\n", __FUNCTION__,
                 c->msgtype);
        return -EINVAL;
    }
    if (debug_avp)
        if (DEBUG)
            _log (LOG_DEBUG, "%s: message type %d (%s)\n", __FUNCTION__,
                 c->msgtype, msgtypes[c->msgtype]);
#ifdef SANITY
    if (t->sanity)

        if ((c != t->self) && (c->msgtype < Hello))
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: attempting to negotiate tunnel inside a call!\n",
                     __FUNCTION__);
            return -EINVAL;

                 */

                if (DEBUG)
                    _log (LOG_DEBUG,
                         "%s: attempting to negotiate SCCRQ with state != 0\n",
                         __FUNCTION__);
                return -EINVAL;

            if (t->state != SCCRQ)
            {
                if (DEBUG)
                    _log (LOG_DEBUG,
                         "%s: attempting to negotiate SCCRP with state != SCCRQ!\n",
                         __FUNCTION__);
                return -EINVAL;

            if (t->state != SCCRP)
            {
                if (DEBUG)
                    _log (LOG_DEBUG,
                         "%s: attempting to negotiate SCCCN with state != SCCRP!\n",
                         __FUNCTION__);
                return -EINVAL;

            if (t->state != SCCCN)
            {
                if (DEBUG)
                    _log (LOG_DEBUG,
                         "%s: attempting to negotiate ICRQ when state != SCCCN\n",
                         __FUNCTION__);
                return -EINVAL;

            if (c != t->self)
            {
                if (DEBUG)
                    _log (LOG_DEBUG,
                         "%s: attempting to negotiate ICRQ on a call!\n",
                         __FUNCTION__);
                return -EINVAL;

            if (t->state != SCCCN)
            {
                if (DEBUG)
                    _log (LOG_DEBUG,
                         "%s: attempting to negotiate ICRP on tunnel!=SCCCN\n",
                         __FUNCTION__);
                return -EINVAL;

            if (c->state != ICRQ)
            {
                if (DEBUG)
                    _log (LOG_DEBUG,
                         "%s: attempting to negotiate ICRP when state != ICRQ\n",
                         __FUNCTION__);
                return -EINVAL;

            if (c->state != ICRP)
            {
                if (DEBUG)
                    _log (LOG_DEBUG,
                         "%s: attempting to negotiate ICCN when state != ICRP\n",
                         __FUNCTION__);
                return -EINVAL;

            if (c->state != ICCN)
            {
                if (DEBUG)
                    _log (LOG_DEBUG,
                         "%s: attempting to negotiate SLI when state != ICCN\n",
                         __FUNCTION__);
                return -EINVAL;

            if (t->state != SCCCN)
            {
                if (DEBUG)
                    _log (LOG_DEBUG,
                         "%s: attempting to negotiate OCRP on tunnel!=SCCCN\n",
                         __FUNCTION__);
                return -EINVAL;

            if (c->state != OCRQ)
            {
                if (DEBUG)
                    _log (LOG_DEBUG,
                         "%s: attempting to negotiate OCRP when state != OCRQ\n",
                         __FUNCTION__);
                return -EINVAL;

            if (c->state != OCRQ)
            {
                if (DEBUG)
                    _log (LOG_DEBUG,
                         "%s: attempting to negotiate OCCN when state != OCRQ\n",
                         __FUNCTION__);
                return -EINVAL;

        case Hello:
            break;
        default:
            _log (LOG_WARN, "%s: i don't know how to handle %s messages\n",
                 __FUNCTION__, msgtypes[c->msgtype]);
            return -EINVAL;
        }

        if (debug_avp)
        {
            if (DEBUG)
                _log (LOG_DEBUG, "%s: new incoming call\n", __FUNCTION__);
        }
        tmp = new_call (t);
        if (!tmp)
        {
            _log (LOG_WARN, "%s: unable to create new call\n", __FUNCTION__);
            return -EINVAL;
        }
        tmp->next = t->call_head;

        if (size < 0)
        {
            if (DEBUG)
                _log (LOG_DEBUG, "%s: Random vector too small (%d < 0)\n",
                     __FUNCTION__, size);
            wrong_length (c, "Random Vector", 6, datalen, 1);
            return -EINVAL;

        if (size > MAX_VECTOR_SIZE)
        {
            if (DEBUG)
                _log (LOG_DEBUG, "%s: Random vector too large (%d > %d)\n",
                     __FUNCTION__, datalen, MAX_VECTOR_SIZE);
            wrong_length (c, "Random Vector", 6, datalen, 1);
            return -EINVAL;
        }
    }
    if (debug_avp)
        _log (LOG_DEBUG, "%s: Random Vector of %d octets\n", __FUNCTION__,
             size);
    t->chal_us.vector = (unsigned char *) &raw[3];
    t->chal_us.vector_len = size;

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG, "%s : Ignoring AVP\n", __FUNCTION__);
    }
    return 0;
}

        if (datalen != 6)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is incorrect size.  %d != 6\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Sequencing Required", 6, datalen, 1);

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: sequencing required not appropriate for %s!\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return -EINVAL;

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG, "%s: peer requires sequencing.\n", __FUNCTION__);
    }
    c->seq_reqd = -1;
    return 0;

        if (datalen < 10)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is incorrect size.  %d < 10\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Result Code", 10, datalen, 1);

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: result code not appropriate for %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

    if ((c->msgtype == StopCCN) && ((result > 7) || (result < 1)))
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: result code out of range (%d %d %d).  Ignoring.\n",
                 __FUNCTION__, result, error, datalen);
        return 0;

    if ((c->msgtype == CDN) && ((result > 11) || (result < 1)))
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: result code out of range (%d %d %d).  Ignoring.\n",
                 __FUNCTION__, result, error, datalen);
        return 0;

    {
        if (DEBUG && (c->msgtype == StopCCN))
        {
            _log (LOG_DEBUG,
                 "%s: peer closing for reason %d (%s), error = %d (%s)\n",
                 __FUNCTION__, result, stopccn_result_codes[result], error,
                 c->errormsg);
        }
        else
        {
            _log (LOG_DEBUG,
                 "%s: peer closing for reason %d (%s), error = %d (%s)\n",
                 __FUNCTION__, result, cdn_result_codes[result], error,
                 c->errormsg);

        if (datalen != 8)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is incorrect size.  %d != 8\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Protocol Version", 8, datalen, 1);

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: protocol version not appropriate for %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: peer is using version %d, revision %d.\n", __FUNCTION__,
                 (ver >> 8), ver & 0xFF);
    }

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: framing capabilities not appropriate for %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen != 10)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is incorrect size.  %d != 10\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Framming Capabilities", 10, datalen, 0);

    caps = ntohs (raw[4]);
    if (debug_avp)
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: supported peer frames:%s%s\n", __FUNCTION__,
                 caps & ASYNC_FRAMING ? " async" : "",
                 caps & SYNC_FRAMING ? " sync" : "");

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: bearer capabilities not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen != 10)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is incorrect size.  %d != 10\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Bearer Capabilities", 10, datalen, 0);

    {
        if (DEBUG)
        {
            _log (LOG_DEBUG,
                 "%s: supported peer bearers:%s%s\n",
                 __FUNCTION__,
                 caps & ANALOG_BEARER ? " analog" : "",

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: firmware revision not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen != 8)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is incorrect size.  %d != 8\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Firmware Revision", 8, datalen, 0);

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: peer reports firmware version %d (0x%.4x)\n",
                 __FUNCTION__, ver, ver);
    }

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: bearer type not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen != 10)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is incorrect size.  %d != 10\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Bearer Type", 10, datalen, 0);

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: peer bears:%s\n", __FUNCTION__,
                 b & ANALOG_BEARER ? " analog" : "digital");
    }

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: frame type not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen != 10)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is incorrect size.  %d != 10\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Frame Type", 10, datalen, 0);

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: peer uses:%s frames\n", __FUNCTION__,
                 b & ASYNC_FRAMING ? " async" : "sync");
    }

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: hostname not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen < 6)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is too small.  %d < 6\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Hostname", 6, datalen, 1);

    if (size > MAXSTRLEN - 1)
    {
        if (DEBUG)
            _log (LOG_DEBUG, "%s: truncating reported hostname (size is %d)\n",
                 __FUNCTION__, size);
        size = MAXSTRLEN - 1;
    }

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: peer reports hostname '%s'\n", __FUNCTION__,
                 t->hostname);
    }

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: dialing number not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen < 6)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is too small.  %d < 6\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Dialing Number", 6, datalen, 1);

    if (size > MAXSTRLEN - 1)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: truncating reported dialing number (size is %d)\n",
                 __FUNCTION__, size);
        size = MAXSTRLEN - 1;

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: peer reports dialing number '%s'\n", __FUNCTION__,
                 t->call_head->dialing);
    }

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: dialed number not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen < 6)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is too small.  %d < 6\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Dialed Number", 6, datalen, 1);

    if (size > MAXSTRLEN - 1)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: truncating reported dialed number (size is %d)\n",
                 __FUNCTION__, size);
        size = MAXSTRLEN - 1;

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: peer reports dialed number '%s'\n", __FUNCTION__,
                 t->call_head->dialed);
    }

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: sub_address not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen < 6)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is too small.  %d < 6\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Sub-address", 6, datalen, 1);

    if (size > MAXSTRLEN - 1)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: truncating reported sub address (size is %d)\n",
                 __FUNCTION__, size);
        size = MAXSTRLEN - 1;

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: peer reports subaddress '%s'\n", __FUNCTION__,
                 t->call_head->subaddy);
    }

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: vendor not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen < 6)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is too small.  %d < 6\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Vendor", 6, datalen, 1);

    if (size > MAXSTRLEN - 1)
    {
        if (DEBUG)
            _log (LOG_DEBUG, "%s: truncating reported vendor (size is %d)\n",
                 __FUNCTION__, size);
        size = MAXSTRLEN - 1;
    }

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: peer reports vendor '%s'\n", __FUNCTION__, t->vendor);
    }
    return 0;

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: challenge not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen < 6)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is too small.  %d < 6\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "challenge", 6, datalen, 1);

    size -= sizeof (struct avp_hdr);
    /* if (size != MD_SIG_SIZE)
    {
        _log (LOG_DEBUG, "%s: Challenge is not the right length (%d != %d)\n",
             __FUNCTION__, size, MD_SIG_SIZE);
        return -EINVAL;
    } */

    t->chal_us.state = STATE_CHALLENGED;
    if (debug_avp)
    {
        _log (LOG_DEBUG, "%s: challenge avp found\n", __FUNCTION__);
    }
    return 0;
}

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: challenge response not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen < 6)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is too small.  %d < 6\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "challenge", 6, datalen, 1);

    size -= sizeof (struct avp_hdr);
    if (size != MD_SIG_SIZE)
    {
        _log (LOG_DEBUG, "%s: Challenge is not the right length (%d != %d)\n",
             __FUNCTION__, size, MD_SIG_SIZE);
        return -EINVAL;
    }

    bcopy (&raw[3], t->chal_them.reply, MD_SIG_SIZE);
    if (debug_avp)
    {
        _log (LOG_DEBUG, "%s: Challenge reply found\n", __FUNCTION__);
    }
    return 0;
}

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: tunnel ID not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen != 8)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is wrong size.  %d != 8\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Assigned Tunnel ID", 8, datalen, 0);

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: using peer's tunnel %d\n", __FUNCTION__,
                 ntohs (raw[3]));
    }

        case OCRQ:
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: call ID not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen != 8)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is wrong size.  %d != 8\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Assigned Call ID", 8, datalen, 0);

    }
    else
    {
        _log (LOG_DEBUG, "%s:  Dunno what to do when it's state %s!\n",
             __FUNCTION__, msgtypes[c->msgtype]);
    }
    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: using peer's call %d\n", __FUNCTION__, ntohs (raw[3]));
    }
    return 0;

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: packet delay not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen != 8)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is wrong size.  %d != 8\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Assigned Call ID", 8, datalen, 0);

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: peer's delay is %d 1/10's of a second\n", __FUNCTION__,
                 ntohs (raw[3]));
    }

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: call ID not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        {
#ifdef STRICT
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is wrong size.  %d != 10\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Serial Number", 10, datalen, 0);
            return -EINVAL;
#else
            _log (LOG_DEBUG,
                 "%s: peer is using old style serial number.  Will be invalid.\n",
                 __FUNCTION__);
#endif

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: serial number is %d\n", __FUNCTION__,
                 t->call_head->serno);
    }

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: rx connect speed not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen != 10)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is wrong size.  %d != 10\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Connect Speed (RX)", 10, datalen, 0);

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: receive baud rate is %d\n", __FUNCTION__, c->rxspeed);
    }
    return 0;

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: tx connect speed not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen != 10)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is wrong size.  %d != 10\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Connect Speed (tx)", 10, datalen, 0);

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: transmit baud rate is %d\n", __FUNCTION__, c->txspeed);
    }
    return 0;

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: physical channel not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen != 10)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is wrong size.  %d != 10\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Physical Channel", 10, datalen, 0);

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: physical channel is %d\n", __FUNCTION__,
                 t->call_head->physchan);
    }

            break;
        default:
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: RWS not appropriate for message %s.  Ignoring.\n",
                     __FUNCTION__, msgtypes[c->msgtype]);
            return 0;

        if (datalen != 8)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: avp is wrong size.  %d != 8\n", __FUNCTION__,
                     datalen);
            wrong_length (c, "Receive Window Size", 8, datalen, 0);

    if (debug_avp)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: peer wants RWS of %d.  Will use flow control.\n",
                 __FUNCTION__, t->rws);
    }

    char *data = buf->start + sizeof (struct control_hdr);
    avp = (struct avp_hdr *) data;
    if (debug_avp)
        _log (LOG_DEBUG, "%s: handling avp's for tunnel %d, call %d\n",
             __FUNCTION__, t->ourtid, c->ourcid);
    while (len > 0)
    {

        {
            if (AMBIT (avp->length))
            {
                _log (LOG_WARN,
                     "%s:  dont know how to handle mandatory attribute %d.  Closing %s.\n"
                     __FUNCTION__, avp->attr,
                     (c != t->self) ? "call" : "tunnel");

            else
            {
                if (DEBUG)
                    _log (LOG_WARN,
                         "%s:  dont know how to handle atribute %d.\n",
                         __FUNCTION__, avp->attr);
                goto next;

        }
        if (ALENGTH (avp->length) > len)
        {
            _log (LOG_WARN,
                 "%s: AVP received with length > remaining packet length!\n",
                 __FUNCTION__);
            set_error (c, ERROR_LENGTH, "Invalid AVP length");

        }
        if (avp->attr && firstavp)
        {
            _log (LOG_WARN, "%s: First AVP was not message type.\n",
                 __FUNCTION__);
            set_error (c, VENDOR_ERROR, "First AVP must be message type");
            c->needclose = -1;

        }
        if (ALENGTH (avp->length) < sizeof (struct avp_hdr))
        {
            _log (LOG_WARN, "%s: AVP with too small of size (%d).\n",
                 __FUNCTION__, ALENGTH (avp->length));
            set_error (c, ERROR_LENGTH, "AVP too small");
            c->needclose = -1;

        }
        if (AZBITS (avp->length))
        {
            _log (LOG_WARN, "%s: %sAVP has reserved bits set.\n", __FUNCTION__,
                 AMBIT (avp->length) ? "Mandatory " : "");
            if (AMBIT (avp->length))
            {

        if (AHBIT (avp->length))
        {
#ifdef DEBUG_HIDDEN
            _log (LOG_DEBUG, "%s: Hidden bit set on AVP.\n", __FUNCTION__);
#endif
            /* We want to rewrite the AVP as an unhidden AVP
               and then pass it along as normal.  Remeber how

            if (decrypt_avp (data, t))
            {
                if (debug_avp)
                    _log (LOG_WARN, "%s: Unable to handle hidden %sAVP\n:",
                         __FUNCTION__,
                         (AMBIT (avp->length) ? "mandatory " : ""));
                if (AMBIT (avp->length))

            {
                if (AMBIT (avp->length))
                {
                    _log (LOG_WARN,
                         "%s: Bad exit status handling attribute %d (%s) on mandatory packet.\n",
                         __FUNCTION__, avp->attr,
                         avps[avp->attr].description);

                else
                {
                    if (DEBUG)
                        _log (LOG_DEBUG,
                             "%s: Bad exit status handling attribute %d (%s).\n",
                             __FUNCTION__, avp->attr,
                             avps[avp->attr].description);

        {
            if (AMBIT (avp->length))
            {
                _log (LOG_WARN,
                     "%s:  No handler for mandatory attribute %d (%s).  Closing %s.\n",
                     __FUNCTION__, avp->attr, avps[avp->attr].description,
                     (c != t->self) ? "call" : "tunnel");

            else
            {
                if (DEBUG)
                    _log (LOG_WARN, "%s:  no handler for atribute %d (%s).\n",
                         __FUNCTION__, avp->attr,
                         avps[avp->attr].description);
            }

    }
    if (len != 0)
    {
        _log (LOG_WARN, "%s: negative overall packet length\n", __FUNCTION__);
        return -EINVAL;
    }
    return 0;




                return 0;
            }
            errors++;
            _log (LOG_DEBUG, "%s: Error %d (%s)\n", __FUNCTION__, errno,
                 strerror (errno));
            if (errors > 10)
            {
                _log (LOG_DEBUG,
                     "%s: Too many errors.  Declaring call dead.\n",
                     __FUNCTION__);
                return -errno;

        case PPP_FLAG:
            if (escape)
            {
                _log (LOG_DEBUG, "%s: got an escaped PPP_FLAG\n",
                     __FUNCTION__);
                return -EINVAL;
            }

                buf->len++;
                break;
            };
            _log (LOG_WARN, "%s: read overrun\n", __FUNCTION__);
            return -EINVAL;
        }
    }
    /* I should never get here */
    _log (LOG_WARN, "%s: You should not see this message.  If you do, please\n\
		       enter a bug report at http://sourceforge.net/projects/l2tpd", __FUNCTION__);
    return -EINVAL;
}

    struct call *tmp, *tmp2;
    if (!c || !c->container)
    {
        _log (LOG_DEBUG, "%s: called on null call or containerless call\n",
             __FUNCTION__);
        return;
    }

                || ((struct tunnel *) se->data == c->container))
            {
#ifdef DEBUG_CLOSE
                _log (LOG_DEBUG, "%s: Descheduling event\n", __FUNCTION__);
#endif
                if (ose)
                {

            /* Really close this tunnel, as our
               StopCCN has been ack'd */
#ifdef DEBUG_CLOSE
            _log (LOG_DEBUG, "%s: Actually closing tunnel %d\n", __FUNCTION__,
                 c->container->ourtid);
#endif
#ifdef USE_KERNEL

        if (packet_dump)
            do_packet_dump (buf);
#ifdef DEBUG_CLOSE
        _log (LOG_DEBUG, "%s: enqueing close message for tunnel\n",
             __FUNCTION__);
#endif
        control_xmit (buf);

            call_close (tmp);
            tmp = tmp2;
        }
        _log (LOG_LOG,
             "%s : Connection %d closed to %s, port %d (%s)\n", __FUNCTION__,
             c->container->tid,
             IPADDY (c->container->peer.sin_addr),

        if (c->closing)
        {
#ifdef DEBUG_CLOSE
            _log (LOG_DEBUG, "%s: Actually closing call %d\n", __FUNCTION__,
                 c->ourcid);
#endif
            destroy_call (c);

        if (packet_dump)
            do_packet_dump (buf);
#ifdef DEBUG_CLOSE
        _log (LOG_DEBUG, "%s: enqueuing close message for call %d\n",
             __FUNCTION__, c->ourcid);
#endif
        control_xmit (buf);
        _log (LOG_LOG, "%s: Call %d to %s disconnected\n", __FUNCTION__,
             c->ourcid, IPADDY (c->container->peer.sin_addr));
    }
    /*

            c->lac->active)
        {
#ifdef DEBUG_MAGIC
            _log (LOG_LOG, "%s: Will redial in %d seconds\n", __FUNCTION__,
                 c->lac->rtimeout);
#endif
            tv.tv_sec = c->lac->rtimeout;

            temp = (int *)entropy_buf;
            tmp->ourcid = *temp & 0xFFFF;
#ifdef DEBUG_ENTROPY
            _log(LOG_DEBUG, "ourcid = %u, entropy_buf = %hx\n", tmp->ourcid, *temp);
#endif
        }
#else

                            return sc;
                        sc = sc->next;
                    }
                    _log (LOG_DEBUG, "%s: can't find call %d in tunnel %d\n",
                         __FUNCTION__, call, tunnel);
                    return NULL;
                }

            }
            st = st->next;
        }
        _log (LOG_DEBUG, "%s:can't find tunnel %d\n", __FUNCTION__, tunnel);
        return NULL;
    }
    else


        if (call)
        {
            _log (LOG_WARN,
                 "%s: call ID specified, but no tunnel ID specified.  tossing.\n",
                 __FUNCTION__);
            return NULL;

         */
        if (debug_tunnel)
        {
            _log (LOG_DEBUG,
                 "%s: allocating new tunnel for host %s, port %d.\n",
                 __FUNCTION__, IPADDY (addr), ntohs (port));
        }
        if (!(st = new_tunnel ()))
        {
            _log (LOG_WARN,
                 "%s: unable to allocate new tunnel for host %s, port %d.\n",
                 __FUNCTION__, IPADDY (addr), ntohs (port));
            return NULL;




    if (packet_dump)
        do_packet_dump (buf);
#ifdef DEBUG_HELLO
    _log (LOG_DEBUG, "%s: sending Hello on %d\n", __FUNCTION__, t->ourtid);
#endif
    control_xmit (buf);
    /*
     * Schedule another Hello in a little bit.
     */
#ifdef DEBUG_HELLO
    _log (LOG_DEBUG, "%s: scheduling another Hello on %d\n", __FUNCTION__,
         t->ourtid);
#endif
    t->hello = schedule (tv, hello, (void *) t);

    add_control_hdr (t, c, buf);
    t->control_seq_num--;
#ifdef DEBUG_ZLB
    _log (LOG_DEBUG, "%s: sending control ZLB on tunnel %d\n", __FUNCTION__,
         t->tid);
#endif
    udp_xmit (buf);

    char dummy_buf[128] = "/var/l2tp/"; /* jz: needed to read /etc/ppp/var.options - just kick it if you dont like */
    if (c->msgtype < 0)
    {
        _log (LOG_DEBUG, "%s: Whoa...  non-ZLB with no message type!\n",
             __FUNCTION__);
        return -EINVAL;
    }
    if (debug_state)
        _log (LOG_DEBUG,
             "%s: message type is %s(%d).  Tunnel is %d, call is %d.\n",
             __FUNCTION__, msgtypes[c->msgtype], c->msgtype, t->tid, c->cid);
    switch (c->msgtype)

            if (packet_dump)
                do_packet_dump (buf);
            if (debug_state)
                _log (LOG_DEBUG, "%s: control_finish: sending SCCRQ\n",
                     __FUNCTION__);
            control_xmit (buf);
        }

                if (packet_dump)
                    do_packet_dump (buf);
                if (debug_state)
                    _log (LOG_DEBUG, "%s: sending ICRQ\n", __FUNCTION__);
                control_xmit (buf);
            }
            else

        if (t->tid <= 0)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Peer did not specify assigned tunnel ID.  Closing.\n",
                     __FUNCTION__);
            set_error (c, VENDOR_ERROR, "Specify your assigned tunnel ID");

        if (!(t->lns = get_lns (t)))
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Denied connection to unauthorized peer %s\n",
                     __FUNCTION__, IPADDY (t->peer.sin_addr));
            set_error (c, VENDOR_ERROR, "No Authorization");

        if (t->fc < 0)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Peer did not specify framing capability.  Closing.\n",
                     __FUNCTION__);
            set_error (c, VENDOR_ERROR, "Specify framing capability");

         * We shouldn't be requiring a bearer capabilities avp to be present in 
         * SCCRQ and SCCRP as they aren't required
         if (t->bc < 0 ) {
         if (DEBUG) _log(LOG_DEBUG,
         "%s: Peer did not specify bearer capability.  Closing.\n",__FUNCTION__);
         set_error(c, VENDOR_ERROR, "Specify bearer capability");
         c->needclose = -1;

        if (!strlen (t->hostname))
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Peer did not specify hostname.  Closing.\n",
                     __FUNCTION__);
            set_error (c, VENDOR_ERROR, "Specify your hostname");

                 * But it is legitimate for two different remote systems
                 * to use the same tid
                 */
                _log (LOG_DEBUG,
                     "%s: Peer requested tunnel %d twice, ignoring second one.\n",
                     __FUNCTION__, t->tid);
                c->needclose = 0;

            t->chal_them.challenge = malloc(MD_SIG_SIZE);
            if (!(t->chal_them.challenge))
            {
                _log (LOG_WARN, "%s: malloc failed\n", __FUNCTION__);
                set_error (c, VENDOR_ERROR, "malloc failed");
                toss (buf);
                return -EINVAL;

            if (handle_challenge (t, &t->chal_them))
            {
                /* We already know what to expect back */
                _log (LOG_WARN, "%s: No secret for '%s'\n", __FUNCTION__,
                     t->hostname);
                set_error (c, VENDOR_ERROR, "No secret on our side");
                toss (buf);

            do_packet_dump (buf);
        c->cnu = 0;
        if (debug_state)
            _log (LOG_DEBUG, "%s: sending SCCRP\n", __FUNCTION__);
        control_xmit (buf);
        break;
    case SCCRP:

        if (t->fc < 0)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Peer did not specify framing capability.  Closing.\n",
                     __FUNCTION__);
            set_error (c, VENDOR_ERROR, "Specify framing capability");

         * We shouldn't be requiring a bearer capabilities avp to be present in 
         * SCCRQ and SCCRP as they aren't required
         if (t->bc < 0 ) {
         if (DEBUG) _log(LOG_DEBUG,
         "%s: Peer did not specify bearer capability.  Closing.\n",__FUNCTION__);
         set_error(c, VENDOR_ERROR, "Specify bearer capability");
         c->needclose = -1;

        if (!strlen (t->hostname))
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Peer did not specify hostname.  Closing.\n",
                     __FUNCTION__);
            set_error (c, VENDOR_ERROR, "Specify your hostname");

        if (t->tid <= 0)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Peer did not specify assigned tunnel ID.  Closing.\n",
                     __FUNCTION__);
            set_error (c, VENDOR_ERROR, "Specify your assigned tunnel ID");

            if (handle_challenge (t, &t->chal_them))
            {
                set_error (c, VENDOR_ERROR, "No secret key on our side");
                _log (LOG_WARN, "%s: No secret key for authenticating '%s'\n",
                     __FUNCTION__, t->hostname);
                c->needclose = -1;
                return -EINVAL;

            {
                set_error (c, VENDOR_ERROR,
                           "Invalid challenge authentication");
                _log (LOG_DEBUG, "%s: Invalid authentication for host '%s'\n",
                     __FUNCTION__, t->hostname);
                c->needclose = -1;
                return -EINVAL;

            t->chal_us.ss = SCCCN;
            if (handle_challenge (t, &t->chal_us))
            {
                _log (LOG_WARN, "%s: No secret for authenticating to '%s'\n",
                     __FUNCTION__, t->hostname);
                set_error (c, VENDOR_ERROR, "No secret key on our end");
                c->needclose = -1;

            do_packet_dump (buf);
        c->cnu = 0;
        if (debug_state)
            _log (LOG_DEBUG, "%s: sending SCCCN\n", __FUNCTION__);
        control_xmit (buf);
        /* Schedule a HELLO */
        tv.tv_sec = HELLO_DELAY;
        tv.tv_usec = 0;
#ifdef DEBUG_HELLO
        _log (LOG_DEBUG, "%s: scheduling initial HELLO on %d\n", __FUNCTION__,
             t->ourtid);
#endif
        t->hello = schedule (tv, hello, (void *) t);
        _log (LOG_LOG,
             "%s: Connection established to %s, %d.  Local: %d, Remote: %d.\n",
             __FUNCTION__, IPADDY (t->peer.sin_addr),
             ntohs (t->peer.sin_port), t->ourtid, t->tid);

            {
                set_error (c, VENDOR_ERROR,
                           "Invalid challenge authentication");
                _log (LOG_DEBUG, "%s: Invalid authentication for host '%s'\n",
                     __FUNCTION__, t->hostname);
                c->needclose = -1;
                return -EINVAL;

        }
#endif
        t->state = SCCCN;
        _log (LOG_LOG,
             "%s: Connection established to %s, %d.  Local: %d, Remote: %d.  LNS session is '%s'\n",
             __FUNCTION__, IPADDY (t->peer.sin_addr),
             ntohs (t->peer.sin_port), t->ourtid, t->tid, t->lns->entname);

        tv.tv_sec = HELLO_DELAY;
        tv.tv_usec = 0;
#ifdef DEBUG_HELLO
        _log (LOG_DEBUG, "%s: scheduling initial HELLO on %d\n", __FUNCTION__,
             t->ourtid);
#endif
        t->hello = schedule (tv, hello, (void *) t);

        if (t->qtid < 0)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Peer tried to disconnect without specifying tunnel ID\n",
                     __FUNCTION__);
            return -EINVAL;

        if ((t->qtid != t->tid) && (t->tid > 0))
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Peer tried to disconnect with invalid TID (%d != %d)\n",
                     __FUNCTION__, t->qtid, t->tid);
            return -EINVAL;

        if (t->self->result < 0)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Peer tried to disconnect without specifying result code.\n",
                     __FUNCTION__);
            return -EINVAL;
        }
        _log (LOG_LOG,
             "%s: Connection closed to %s, port %d (%s), Local: %d, Remote: %d\n",
             __FUNCTION__, IPADDY (t->peer.sin_addr),
             ntohs (t->peer.sin_port), t->self->errormsg, t->ourtid, t->tid);

        if (p->cid < 0)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Peer tried to initiate call without call ID\n",
                     __FUNCTION__);
            /* Here it doesn't make sense to use the needclose flag because 

            {
                /* This can happen if we get a duplicate
                   ICRQ or if they don't get our ack packet */
                _log (LOG_DEBUG,
                     "%s: Peer requested call %d twice, ignoring second one.\n",
                     __FUNCTION__, p->cid);
                p->needclose = 0;

         * number avp is included in the ICRQ at all which its required to be.
         * Since the serial number is only used for human debugging aid, this
         * isn't a big deal, but it would be nice to have *some* sort of check
         * for it and perhaps just _log it and go on.  */
/*    JLM	if (p->serno<1) {
			if (DEBUG) _log(LOG_DEBUG,
			"%s: Peer did not specify serial number when initiating call\n", __FUNCTION__);
			call_close(p);
			return -EINVAL;

        {
            set_error (p, ERROR_NORES, "No available IP address");
            call_close (p);
            _log (LOG_DEBUG, "%s: Out of IP addresses on tunnel %d!\n",
                 __FUNCTION__, t->tid);
            return -EINVAL;
        }

            do_packet_dump (buf);
        p->cnu = 0;
        if (debug_state)
            _log (LOG_DEBUG, "%s: Sending ICRP\n", __FUNCTION__);
        control_xmit (buf);
        break;
    case ICRP:
        if (c->cid < 0)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Peer tried to negotiate ICRP without specifying call ID\n",
                     __FUNCTION__);
            c->needclose = -1;

        }
#endif
        if (debug_state)
            _log (LOG_DEBUG, "%s: Sending ICCN\n", __FUNCTION__);
        _log (LOG_LOG,
             "%s: Call established with %s, Local: %d, Remote: %d, Serial: %d\n",
             __FUNCTION__, IPADDY (t->peer.sin_addr), c->ourcid, c->cid,
             c->serno);

    case ICCN:
        if (c == t->self)
        {
            _log (LOG_DEBUG,
                 "%s: Peer attempted ICCN on the actual tunnel, not the call",
                 __FUNCTION__);
            return -EINVAL;
        }
        if (c->txspeed < 1)
        {
            _log (LOG_DEBUG,
                 "%s: Peer did not specify transmit speed\n", __FUNCTION__);
            c->needclose = -1;
            return -EINVAL;
        };
        if (c->frame < 1)
        {
            _log (LOG_DEBUG,
                 "%s: Peer did not specify framing type\n", __FUNCTION__);
            c->needclose = -1;
            return -EINVAL;

        }
        start_pppd (c, po);
        opt_destroy (po);
        _log (LOG_LOG,
             "%s: Call established with %s, Local: %d, Remote: %d, Serial: %d\n",
             __FUNCTION__, IPADDY (t->peer.sin_addr), c->ourcid, c->cid,
             c->serno);

        };
        start_pppd (c, po);

        _log (LOG_LOG, "parameters: Local: %d , Remote: %d , Serial: %d , Pid: %d , Tunnelid: %d , Phoneid: %s\n", c->ourcid, c->cid, c->serno, c->pppd, t->ourtid, c->dial_no); /*  jz: just show some information */

        opt_destroy (po);
        if (c->lac)

        if (c->qcid < 0)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Peer tried to disconnect without specifying call ID\n",
                     __FUNCTION__);
            return -EINVAL;

            if (!p)
            {
                if (DEBUG)
                    _log (LOG_DEBUG,
                         "%s: Unable to determine call to be disconnected.\n",
                         __FUNCTION__);
                return -EINVAL;

        if ((c->qcid != p->cid) && p->cid > 0)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Peer tried to disconnect with invalid CID (%d != %d)\n",
                     __FUNCTION__, c->qcid, c->cid);
            return -EINVAL;

        if (c->result < 0)
        {
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Peer tried to disconnect without specifying result code.\n",
                     __FUNCTION__);
            return -EINVAL;
        }
        _log (LOG_LOG,
             "%s: Connection closed to %s, serial %d (%s)\n", __FUNCTION__,
             IPADDY (t->peer.sin_addr), c->serno, c->errormsg);
        c->needclose = 0;

    case SLI:
        break;
    default:
        _log (LOG_DEBUG,
             "%s: Don't know how to finish a message of type %d\n",
             __FUNCTION__, c->msgtype);
        set_error (c, VENDOR_ERROR, "Unimplemented message %d\n", c->msgtype);

    {
        if (DEBUG)
        {
            _log (LOG_DEBUG,
                 "%s: Received too small of packet\n", __FUNCTION__);
        }
        return -EINVAL;

    {
        if (DEBUG)
        {
            _log (LOG_DEBUG,
                 "%s: Reported and actual sizes differ (%d != %d)\n",
                 __FUNCTION__, h->length, buf->len);
        }

     * FIXME: H-bit handling goes here
     */
#ifdef DEBUG_CONTROL
    _log (LOG_DEBUG, "%s: control, cid = %d, Ns = %d, Nr = %d\n", __FUNCTION__,
         c->cid, h->Ns, h->Nr);
#endif
    if (h->Ns != t->control_rec_seq_num)
    {
        if (DEBUG)
            _log (LOG_DEBUG,
                 "%s: Received out of order control packet on tunnel %d (%d != %d)\n",
                 __FUNCTION__, t->tid, h->Ns, t->control_rec_seq_num);
        if (((h->Ns < t->control_rec_seq_num) && 

             */
#ifdef DEBUG_ZLB
            if (DEBUG)
                _log (LOG_DEBUG, "%s: Sending an updated ZLB in reponse\n",
                     __FUNCTION__);
#endif
            zlb = new_outgoing (t);

        {
            if (DEBUG)
            {
                _log (LOG_DEBUG, "%s: Control bit not set\n", __FUNCTION__);
            }
            return -EINVAL;
        }

        {
            if (DEBUG)
            {
                _log (LOG_DEBUG, "%s: Length bit not set\n", __FUNCTION__);
            }
            return -EINVAL;
        }

        {
            if (DEBUG)
            {
                _log (LOG_DEBUG, "%s: Flow bit not set\n", __FUNCTION__);
            }
            return -EINVAL;
        }

            {
                if (CVER (h->ver) == VER_PPTP)
                {
                    _log (LOG_DEBUG,
                         "%s: PPTP packet received\n", __FUNCTION__);
                }
                else if (CVER (h->ver) < VER_L2TP)
                {
                    _log (LOG_DEBUG,
                         "%s: L2F packet received\n", __FUNCTION__);
                }
                else
                {
                    _log (LOG_DEBUG,
                         "%s: Unknown version received\n", __FUNCTION__);
                }
            }

    {
        if (DEBUG)
        {
            _log (LOG_DEBUG, "%s: Aempted to send payload on tunnel\n",
                 __FUNCTION__);
        }
        return -EINVAL;

           no matter what.  we'll look more later */
        if (DEBUG)
        {
            _log (LOG_DEBUG, "%s:Recieved to small of packet\n", __FUNCTION__);
        }
        return -EINVAL;
    }

        {
            if (DEBUG)
            {
                _log (LOG_DEBUG, "%s Control bit set\n", __FUNCTION__);
            }
            return -EINVAL;
        }

        {
/*			if (!c->fbit && !c->ourfbit) {
				if (DEBUG)
					_log(LOG_DEBUG,"%s: flow bit set, but no RWS negotiated.\n",__FUNCTION__);
				return -EINVAL;
			} */
            ehlen += 4;         /* Should have Ns and Nr too */

/*		if (!PFBIT(h->ver)) {
			if (c->fbit || c->ourfbit) {
				if (DEBUG)
					_log(LOG_DEBUG, "%s: no flow bit, but RWS was negotiated.\n",__FUNCTION__);
				return -EINVAL;;
			}
		} */

            {
                if (PVER (h->ver) == VER_PPTP)
                {
                    _log (LOG_DEBUG, "%s: PPTP packet received\n",
                         __FUNCTION__);
                }
                else if (CVER (h->ver) < VER_L2TP)
                {
                    _log (LOG_DEBUG, "%s: L2F packet received\n",
                         __FUNCTION__);
                }
                else
                {
                    _log (LOG_DEBUG, "%s: Unknown version received\n",
                         __FUNCTION__);
                }
            }

        {
            if (DEBUG)
            {
                _log (LOG_DEBUG, "%s payload too small (%d < %d)\n",
                     __FUNCTION__, buf->len, ehlen);
            }
            return -EINVAL;

        {
            if (DEBUG)
            {
                _log (LOG_DEBUG, "%s: size mismatch (%d != %d)\n",
                     __FUNCTION__, buf->len, h->length);
            }
            return -EINVAL;

        new_hdr = (struct payload_hdr *) (buf->start - ehlen);
        if ((void *) new_hdr < (void *) buf->rstart)
        {
            _log (LOG_WARN, "%s: not enough space to decompress frame\n",
                 __FUNCTION__);
            return -EINVAL;


     */
/*  JLM	if (PRBIT(new_hdr->ver)) {
		if (c->pSr > new_hdr->Ns) {
			_log(LOG_DEBUG, "%s: R-bit set with Ns < pSr!\n",__FUNCTION__);
			return -EINVAL;
		}
#ifdef DEBUG_FLOW
		_log(LOG_DEBUG, "%s: R-bit set on packet %d\n",__FUNCTION__,new_hdr->Ns);
#endif
		c->pSr=new_hdr->Ns;
	} */
#ifdef DEBUG_PAYLOAD
    _log (LOG_DEBUG, "%s: payload, cid = %d, Ns = %d, Nr = %d\n", __FUNCTION__,
         c->cid, new_hdr->Ns, new_hdr->Nr);
#endif
    if (new_hdr->Ns != c->data_seq_num)

        {
#ifdef DEBUG_FLOW
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Already seen this packet before (%d < %d)\n",
                     __FUNCTION__, new_hdr->Ns, c->pSr);
#endif

            /* FIXME: I should buffer for out of order packets */
#ifdef DEBUG_FLOW
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Oops, lost a packet or two (%d != %d).  continuing...\n",
                     __FUNCTION__, new_hdr->Ns, c->pSr);
#endif

        {
#ifdef DEBUG_FLOW
            if (DEBUG)
                _log (LOG_DEBUG,
                     "%s: Received out of order payload packet (%d != %d)\n",
                     __FUNCTION__, new_hdr->Ns, c->pSr);
#endif

    c = (struct call *) data;
    if (!c)
    {
        _log (LOG_WARN, "%s: called on NULL call\n", __FUNCTION__);
        return;
    }
    t = c->container;
    if (!t)
    {
        _log (LOG_WARN, "%s: called on call with NULL container\n",
             __FUNCTION__);
        return;
    }

    c->data_seq_num--;                   /* We don't increment on ZLB's */
    c->zlb_xmit = NULL;
#ifdef DEBUG_ZLB
    _log (LOG_DEBUG, "%s: sending payload ZLB\n", __FUNCTION__);
#endif
    udp_xmit (buf);
    toss (buf);

    if (c->fd < 0)
    {
        if (DEBUG)
            _log (LOG_DEBUG, "%s: tty is not open yet.\n", __FUNCTION__);
        return -EIO;
    }
    /*

        }
        else if (err == 0)
        {
            _log (LOG_WARN, "%s: wrote no bytes of async packet\n",
                 __FUNCTION__);
            return -EINVAL;
        }

            }
            else
            {
                _log (LOG_WARN, "%s: async write failed: %s\n", __FUNCTION__,
                     strerror (errno));
            }
        }
        else if (err < buf->len)
        {
            _log (LOG_WARN, "%s: short write (%d of %d bytes)\n", __FUNCTION__,
                 err, buf->len);
            return -EINVAL;
        }
        else if (err > buf->len)
        {
            _log (LOG_WARN, "%s: write returned LONGER than buffer length?\n",
                 __FUNCTION__);
            return -EINVAL;
        }

               * everything ended normally
             */
            if (DEBUG)
                _log (LOG_WARN, "%s: %s(%d)\n", __FUNCTION__, strerror (errno),
                     errno);
            c->needclose = -1;
            c->fd = -1;

        {
            /* If it's a ZLB, we ignore it */
            if (debug_tunnel)
                _log (LOG_DEBUG, "%s: ZLB for closed call\n", __FUNCTION__);
            c->cid = 0;
            return;
        }

    {
        c->cid = 0;
        if (debug_tunnel)
            _log (LOG_DEBUG, "%s: invalid control packet\n", __FUNCTION__);
    }
}


            if (buf->len == sizeof (struct control_hdr))
            {
#ifdef DEBUG_ZLB
                _log (LOG_DEBUG, "%s: control ZLB received\n", __FUNCTION__);
#endif
                t->control_rec_seq_num--;
                c->cnu = 0;

                    if (c->container->cLr >= c->closeSs)
                    {
#ifdef DEBUG_ZLB
                        _log (LOG_DEBUG, "%s: ZLB for closing message found\n",
                             __FUNCTION__);
#endif
                        c->needclose = 0;

            else
            {
                if (debug_tunnel)
                    _log (LOG_DEBUG, "%s: bad AVP handling!\n", __FUNCTION__);
                return -EINVAL;
            }
        }
        else
        {
            _log (LOG_DEBUG, "%s: bad control packet!\n", __FUNCTION__);
            return -EINVAL;
        }
    }

/*					if (c->throttle) {
						if (c->pSs > c->pLr + c->rws) {
#ifdef DEBUG_FLOW
							_log(LOG_DEBUG, "%s: not yet dethrottling call\n",__FUNCTION__);
#endif
						} else {
#ifdef DEBUG_FLOW
							_log(LOG_DEBUG, "%s: dethrottling call\n",__FUNCTION__);
#endif
							if (c->dethrottle) deschedule(c->dethrottle);
							c->dethrottle=NULL;

						We've received enough to fill our receive window.  At
						this point, we should immediately send a ZLB!
#ifdef DEBUG_ZLB
							_log(LOG_DEBUG, "%s: Sending immediate ZLB!\n",__FUNCTION__);
#endif
							if (c->zlb_xmit) {
							Deschedule any existing zlb_xmit's

							if (c->zlb_xmit)
								deschedule(c->zlb_xmit);
#ifdef DEBUG_ZLB
							_log(LOG_DEBUG, "%s: scheduling ZLB\n",__FUNCTION__);
#endif
							c->zlb_xmit = schedule(tv, &send_zlb, (void *)c);
						}

                else if (buf->len == sizeof (struct payload_hdr))
                {
#ifdef DEBUG_ZLB
                    _log (LOG_DEBUG, "%s: payload ZLB received\n",
                         __FUNCTION__);
#endif
/*					if (c->throttle) {
						if (c->pSs > c->pLr + c->rws) {
#ifdef DEBUG_FLOW
							_log(LOG_DEBUG, "%s: not yet dethrottling call\n",__FUNCTION__);
#endif
						} else {
#ifdef DEBUG_FLOW
							_log(LOG_DEBUG, "%s: dethrottling call\n",__FUNCTION__);
#endif
							if (c->dethrottle)
								deschedule(c->dethrottle);

                }
                else
                {
                    _log (LOG_DEBUG, "%s: payload too small!\n", __FUNCTION__);
                    return -EINVAL;
                }
            }
            else
            {
                if (debug_tunnel)
                    _log (LOG_DEBUG, "%s: unable to expand payload!\n",
                         __FUNCTION__);
                return -EINVAL;
            }
        }
        else
        {
            _log (LOG_DEBUG, "%s: invalid payload packet!\n", __FUNCTION__);
            return -EINVAL;
        }
    }




        }
        else
        {
            _log (LOG_CRIT, "%s: Unable to open config file %s or %s\n",
                 __FUNCTION__, gconfig.configfile, gconfig.altconfigfile);
            return -1;
        }

    tmp = (struct lns *) malloc (sizeof (struct lns));
    if (!tmp)
    {
        _log (LOG_CRIT, "%s: Unable to allocate memory for new LNS\n",
             __FUNCTION__);
        return NULL;
    }

    tmp = (struct lac *) malloc (sizeof (struct lac));
    if (!tmp)
    {
        _log (LOG_CRIT, "%s: Unable to allocate memory for lac entry!\n",
             __FUNCTION__);
        return NULL;
    }

{
    int val;
#ifdef DEBUG_FILE
    _log (LOG_DEBUG, "set_%s: %s  flag to '%s'\n", word, word, value);
#endif /* ; */
    if ((val = yesno (value)) < 0)
    {

{
    int val;
#ifdef DEBUG_FILE
    _log (LOG_DEBUG, "set_%s: %s  flag to '%s'\n", word, word, value);
#endif /* ; */
    if ((val = atoi (value)) < 0)
    {

int set_string (char *word, char *value, char *ptr, int len)
{
#ifdef DEBUG_FILE
    _log (LOG_DEBUG, "set_%s: %s  flag to '%s'\n", word, word, value);
#endif /* ; */
    strncpy (ptr, value, len);
    return 0;

    {
    case CONTEXT_GLOBAL:
#ifdef DEBUG_FILE
        _log (LOG_DEBUG, "set_port: Setting global port number to %s\n",
             value);
#endif
        set_int (word, value, &(((struct global *) item)->port));

    {
    case CONTEXT_LAC:
#ifdef DEBUG_FILE
        _log (LOG_DEBUG, "set_rtimeout: Setting redial timeout to %s\n",
             value);
#endif
        set_int (word, value, &(((struct lac *) item)->rtimeout));

    {
    case CONTEXT_LAC:
#ifdef DEBUG_FILE
        _log (LOG_DEBUG, "set_rmax: Setting max redials to %s\n", value);
#endif
        set_int (word, value, &(((struct lac *) item)->rmax));
        break;

    {
    case CONTEXT_GLOBAL:
#ifdef DEBUG_FILE
        _log (LOG_DEBUG, "set_authfile: Setting global auth file to '%s'\n",
             value);
#endif /* ; */
        strncpy (((struct global *) item)->authfile, value,

    if (!lns->range)
        return -1;
#ifdef DEBUG_FILE
    _log (LOG_DEBUG, "range start = %x, end = %x, sense=%ud\n",
         ntohl (ipr->start), ntohl (ipr->end), ipr->sense);
#endif
    return 0;

    if (!lns->lacs)
        return -1;
#ifdef DEBUG_FILE
    _log (LOG_DEBUG, "lac start = %x, end = %x, sense=%ud\n",
         ntohl (ipr->start), ntohl (ipr->end), ipr->sense);
#endif
    return 0;

    {
    case CONTEXT_LAC:
#ifdef DEBUG_FILE
        _log (LOG_DEBUG, "set_lns: setting LNS to '%s'\n", value);
#endif
        l = (struct lac *) item;
        d = strchr (value, ':');


int set_rand_sys ()
{
    _log(LOG_WARN, "The \"rand()\" function call is not a very good source"
            "of randomness\n");
   rand_source = RAND_SYS;
    return 0;


int set_rand_egd (char *value)
{
    _log(LOG_WARN, "%s: not yet implemented!\n", __FUNCTION__);
    rand_source = RAND_EGD;
    return -1;
}

 
    if (context != CONTEXT_GLOBAL)
    {
        _log(LOG_WARN, "%s: %s not valid in context %d\n",
                __FUNCTION__, word, context);
        return -1;
    }

    }
    else
    {
        _log(LOG_WARN, "%s: %s is not a valid randomness source\n",
                __FUNCTION__, value);
        return -1;


            /* We've got a context description */
            if (!(t = strchr (s, ']')))
            {
                _log (LOG_CRIT, "parse_config: line %d: No closing bracket\n",
                     linenum);
                return -1;
            }

            {
                context = CONTEXT_GLOBAL;
#ifdef DEBUG_FILE
                _log (LOG_DEBUG,
                     "parse_config: global context descriptor %s\n",
                     d ? d : "");
#endif

                    strncpy (((struct lns *) data)->entname,
                             d, sizeof (((struct lns *) data)->entname));
#ifdef DEBUG_FILE
                _log (LOG_DEBUG, "parse_config: lns context descriptor %s\n",
                     d ? d : "");
#endif
            }

                    strncpy (((struct lac *) data)->entname,
                             d, sizeof (((struct lac *) data)->entname));
#ifdef DEBUG_FILE
                _log (LOG_DEBUG, "parse_config: lac context descriptor %s\n",
                     d ? d : "");
#endif
            }
            else
            {
                _log (LOG_WARN,
                     "parse_config: line %d: unknown context '%s'\n", linenum,
                     s);
                return -1;

        {
            if (!context)
            {
                _log (LOG_WARN,
                     "parse_config: line %d: data '%s' occurs with no context\n",
                     linenum, s);
                return -1;
            }
            if (!(t = strchr (s, '=')))
            {
                _log (LOG_WARN, "parse_config: line %d: no '=' in data\n",
                     linenum);
                return -1;
            }

            while (*t && (*t < 33))
                t++;
#ifdef DEBUG_FILE
            _log (LOG_DEBUG, "parse_config: field is %s, value is %s\n", s, t);
#endif
            /* Okay, bit twidling is done.  Let's handle this */
            for (kw = words; kw->keyword; kw++)

                {
                    if (kw->handler (s, t, context | def, data))
                    {
                        _log (LOG_WARN, "parse_config: line %d: %s", linenum,
                             filerr);
                        return -1;
                    }

            }
            if (!kw->keyword)
            {
                _log (LOG_CRIT, "parse_config: line %d: Unknown field '%s'\n",
                     linenum, s);
                return -1;
            }




    FILE *f = fdopen (fd2, "a");
    if (!f)
    {
        _log (LOG_WARN, "show_status: fdopen() failed on fd %d\n", fd);
        return;
    }
    fprintf (f, "====== l2tpd statistics ========\n");

        {
            if (c->pppd == pid)
            {
                _log (LOG_DEBUG, "%s : pppd died for call %d\n", __FUNCTION__,
                     c->cid);
                c->needclose = -1;
                /* 

     */
    struct tunnel *st, *st2;
    int sec;
    _log (LOG_CRIT, "%s: Fatal signal %d received\n", __FUNCTION__, signal);
    st = tunnels.head;
    while (st)
    {

    stropt[pos] = NULL;
    if (c->pppd > 0)
    {
        _log (LOG_WARN, "%s: PPP already started on call!\n", __FUNCTION__);
        return -EINVAL;
    }
    if (c->fd > -1)
    {
        _log (LOG_WARN, "%s: file descriptor already assigned!\n",
             __FUNCTION__);
        return -EINVAL;
    }

#endif
        if ((c->fd = getPtyMaster (&a, &b)) < 0)
        {
            _log (LOG_WARN, "%s: unable to allocate pty, abandoning!\n",
                 __FUNCTION__);
            return -EINVAL;
        }

#endif
    str = stropt[0];
#ifdef DEBUG_PPPD
    _log (LOG_DEBUG, "%s: I'm running:  ", __FUNCTION__);
    for (x = 0; stropt[x]; x++)
    {
        _log (LOG_DEBUG, "\"%s\" ", stropt[x]);
    };
    _log (LOG_DEBUG, "\n");
#endif
    c->pppd = fork ();
    if (c->pppd < 0)
    {
        _log (LOG_WARN, "%s: unable to fork(), abandoning!\n", __FUNCTION__);
        return -EINVAL;
    }
    else if (!c->pppd)

        if (fd2 < 0)
#endif
        {
            _log (LOG_WARN, "%s: Unable to open %s to launch pppd!\n",
                 __FUNCTION__, tty);
            exit (1);
        }

        close (control_fd);

        execv (PPPD, stropt);
        _log (LOG_WARN, "%s: Exec of %s failed!\n", __FUNCTION__, PPPD);
        exit (1);
    };
    close (fd2);

            }
            else
            {
                _log (LOG_WARN,
                     "%s: unable to locate tunnel in tunnel list\n",
                     __FUNCTION__);
            }
        }
        else
        {
            _log (LOG_WARN, "%s: tunnel list is empty!\n", __FUNCTION__);
        }
    }
    if (t->lac)

        if (t->lac->redial && (t->lac->rtimeout > 0) && !t->lac->rsched &&
            t->lac->active)
        {
            _log (LOG_LOG, "%s: Will redial in %d seconds\n", __FUNCTION__,
                 t->lac->rtimeout);
            tv.tv_sec = t->lac->rtimeout;
            tv.tv_usec = 0;

    hp = gethostbyname (host);
    if (!hp)
    {
        _log (LOG_WARN, "%s: gethostbyname() failed for %s.\n", __FUNCTION__,
             host);
        return NULL;
    }

    tmp = get_call (0, 0, addr, port);
    if (!tmp)
    {
        _log (LOG_WARN, "%s: Unable to create tunnel to %s.\n", __FUNCTION__,
             host);
        return NULL;
    }

    /*
     * Since our state is 0, we will establish a tunnel now
     */
    _log (LOG_LOG, "%s:Connecting to host %s, port %d\n", __FUNCTION__, host,
         ntohs (port));
    control_finish (tmp->container, tmp);
    return tmp->container;

    lac = (struct lac *) data;
    if (!lac)
    {
        _log (LOG_WARN, "%s: magic_lac_tunnel: called on NULL lac!\n",
             __FUNCTION__);
        return;
    }

    }
    else
    {
        _log (LOG_WARN, "%s: Unable to find hostname to dial for '%s'\n",
             __FUNCTION__, lac->entname);
        return;
    }

            tmp = new_call (t);
            if (!tmp)
            {
                _log (LOG_WARN, "%s: unable to create new call\n",
                     __FUNCTION__);
                return NULL;
            }

            tmp->lns = lns;
            if (lac)
                lac->c = tmp;
            _log (LOG_LOG, "%s: Calling on tunnel %d\n", __FUNCTION__, tid);
            strcpy (tmp->dial_no, dial_no_tmp); /*  jz: copy dialnumber to tmp->dial_no  */
            control_finish (t, tmp);
            return tmp;
        }
        t = t->next;
    };
    _log (LOG_DEBUG, "%s: No such tunnel %d to generate call.\n", __FUNCTION__,
         tid);
    return NULL;
}

    lac = (struct lac *) data;
    if (!lac->active)
    {
        _log (LOG_DEBUG, "%s: LAC %s not active", __FUNCTION__, lac->entname);
        return;
    }
    lac->rsched = NULL;
    lac->rtries++;
    if (lac->rmax && (lac->rtries > lac->rmax))
    {
        _log (LOG_LOG, "%s: maximum retries exceeded.\n", __FUNCTION__);
        return;
    }
    if (!lac)
    {
        _log (LOG_WARN, "%s : called on NULL lac!\n", __FUNCTION__);
        return;
    }
    if (!lac->t)
    {
#ifdef DEGUG_MAGIC
        _log (LOG_DEBUG, "%s : tunnel not up!  Connecting!\n", __FUNCTION__);
#endif
        magic_lac_tunnel (lac);
        return;

        {
            if (tmp->ourcid == cid)
            {
                _log (LOG_LOG,
                     "%s :Hanging up call %d, Local: %d, Remote: %d\n",
                     __FUNCTION__, tmp->serno, tmp->ourcid, tmp->cid);
                strcpy (tmp->errormsg, "Goodbye!");

        }
        t = t->next;
    };
    _log (LOG_DEBUG, "%s : No such call %d to hang up.\n", __FUNCTION__, cid);
    return;
}


    {
        if (t->ourtid == tid)
        {
            _log (LOG_LOG,
                 "%s: Disconnecting from %s, Local: %d, Remote: %d\n",
                 __FUNCTION__, IPADDY (t->peer.sin_addr), t->ourtid, t->tid);
            t->self->needclose = -1;

        }
        t = t->next;
    };
    _log (LOG_DEBUG, "%s: No such tunnel %d to hang up.\n", __FUNCTION__, tid);
    return;
}


            temp = (int *)entropy_buf;
            tmp->ourtid = *temp & 0xFFFF;
#ifdef DEBUG_ENTROPY
            _log(LOG_DEBUG, "ourtid = %u, entropy_buf = %hx\n", tmp->ourtid, *temp);
#endif
        }
#else

            if (buf[cnt - 1] == '\n')
                buf[--cnt] = 0;
#ifdef DEBUG_CONTROL
            _log (LOG_DEBUG, "%s: Got message %s (%d bytes long)\n",
                 __FUNCTION__, buf, cnt);
#endif
            switch (buf[0])

            case 't':
                host = strchr (buf, ' ') + 1;
#ifdef DEBUG_CONTROL
                _log (LOG_DEBUG, "%s: Attempting to tunnel to %s\n",
                     __FUNCTION__, host);
#endif
                l2tp_call (host, UDP_LISTEN_PORT, NULL, NULL);

                        if (!lac->c)
                            magic_lac_dial (lac);
                        else
                            _log (LOG_DEBUG,
                                 "%s: Session '%s' already active!\n",
                                 __FUNCTION__, lac->entname);
                        break;

                tunl = atoi (tunstr);
                if (!tunl)
                {
                    _log (LOG_DEBUG, "%s: No such tunnel '%s'\n", __FUNCTION__,
                         tunstr);
                    break;
                }
#ifdef DEBUG_CONTROL
                _log (LOG_DEBUG, "%s: Attempting to call on tunnel %d\n",
                     __FUNCTION__, tunl);
#endif
                lac_call (tunl, NULL, NULL);

                        if (!lac->c)
                            magic_lac_dial (lac);
                        else
                            _log (LOG_DEBUG,
                                 "%s: Session '%s' already active!\n",
                                 __FUNCTION__, lac->entname);
                        break;

                tunl = atoi (tunstr);
                if (!tunl)
                {
                    _log (LOG_DEBUG, "%s: No such tunnel '%s'\n", __FUNCTION__,
                         tunstr);
                    break;
                }
#ifdef DEBUG_CONTROL
                _log (LOG_DEBUG, "%s: Attempting to call on tunnel %d\n",
                     __FUNCTION__, tunl);
#endif
                lac_call (tunl, NULL, NULL);

                callstr = strchr (buf, ' ') + 1;
                call = atoi (callstr);
#ifdef DEBUG_CONTROL
                _log (LOG_DEBUG, "%s: Attempting to call %d\n", __FUNCTION__,
                     call);
#endif
                lac_hangup (call);

                        if (lac->t)
                            lac_disconnect (lac->t->ourtid);
                        else
                            _log (LOG_DEBUG, "%s: Session '%s' not up\n",
                                 __FUNCTION__, lac->entname);
                        break;
                    }

                tunl = atoi (tunstr);
                if (!tunl)
                {
                    _log (LOG_DEBUG, "%s: No such tunnel '%s'\n", __FUNCTION__,
                         tunstr);
                    break;
                }
#ifdef DEBUG_CONTROL
                _log (LOG_DEBUG, "%s: Attempting to disconnect tunnel %d\n",
                     __FUNCTION__, tunl);
#endif
                lac_disconnect (tunl);

                show_status (1);
                break;
            default:
                _log (LOG_DEBUG, "%s: Unknown command %c\n", __FUNCTION__,
                     buf[0]);
            }
        }

    int pidfilewritten=0;

    if((pid = fork()) < 0) {
        _log(LOG_LOG, "%s: Unable to fork ()\n",__FUNCTION__);
        close(server_socket);
        exit(1);
    }

    if ((i = open(gconfig.pidfile,O_RDONLY)) > 0) {
        l=read(i,buf,sizeof(buf)-1);
        if (i < 0) {
            _log(LOG_LOG, "%s: Unable to read pid file [%s]\n",
                    __FUNCTION__, gconfig.pidfile);
        }
        buf[i] = '\0';

        }
        else
        {
            _log(LOG_LOG, "%s: There's already a l2tpd server running.\n",
                    __FUNCTION__);
            close(server_socket);
            exit(1);

    init_addr ();
    if (init_config ())
    {
        _log (LOG_CRIT, "%s: Unable to load config file\n", __FUNCTION__);
        exit (1);
    }
    if (uname (&uts))
    {
        _log (LOG_CRIT, "%s : Unable to determine host system\n",
             __FUNCTION__);
        exit (1);
    }

    control_fd = open (CONTROL_PIPE, O_RDONLY | O_NONBLOCK, 0600);
    if (control_fd < 0)
    {
        _log (LOG_CRIT, "%s: Unable to open " CONTROL_PIPE " for reading.",
             __FUNCTION__);
        exit (1);
    }
    _log (LOG_LOG, "l2tpd version " SERVER_VERSION " started on %s PID:%d\n",
         hostname, getpid ());
    _log (LOG_LOG,
         "Written by Mark Spencer, Copyright (C) 1998, Adtran, Inc.\n");
    _log (LOG_LOG, "Forked by Scott Balmos and David Stipp, (C) 2001\n");
    _log (LOG_LOG, "Inhereted by Jeff McAdams, (C) 2002\n");
    _log (LOG_LOG, "%s version %s on a %s, port %d\n", uts.sysname,
         uts.release, uts.machine, gconfig.port);
    lac = laclist;
    while (lac)

        if (lac->autodial)
        {
#ifdef DEBUG_MAGIC
            _log (LOG_DEBUG, "%s: Autodialing '%s'\n", __FUNCTION__,
                 lac->entname[0] ? lac->entname : "(unnamed)");
#endif
            lac->active = -1;




#include "l2tp.h"


void _log (int level, const char *fmt, ...)
{
    char buf[256];
    va_list args;

            c++;                /* again two characters to display ONE byte */
        }
        *c = '\0';
        _log (LOG_WARN, "%s: buflen=%d, buffer[%d]: *%s*\n", __FUNCTION__,
             buflen, i, line);
    }


    if (c != line)
    {
        *c = '\0';
        _log (LOG_WARN, "%s:             buffer[%d]: *%s*\n", __FUNCTION__, i,
             line);
    }
}

    new = (struct ppp_opts *) malloc (sizeof (struct ppp_opts));
    if (!new)
    {
        _log (LOG_WARN,
             "%s : Unable to allocate ppp option memory.  Expect a crash\n",
             __FUNCTION__);
        return NULL;

    if (devrandom == -1)
    {
#ifdef DEBUG_ENTROPY
        _log(LOG_WARN, "%s: couldn't open /dev/urandom,"
                      "falling back to rand()\n",
                      __FUNCTION__);
#endif

    }
    else if (rand_source == RAND_EGD)
    {
        _log(LOG_WARN, "%s: EGD Randomness source not yet implemented\n",
                __FUNCTION__);
        return -1;
    }
    else
    {
        _log(LOG_WARN, "%s: Invalid Randomness source specified (%d)\n",
                __FUNCTION__, rand_source);
        return -1;
    }

Lines 64-70 Link Here

(-)l2tpd-0.69/misc.h (-1 / +1 lines)
64	#define halt() printf("Halted.\n") ; for(;;)	64	#define halt() printf("Halted.\n") ; for(;;)
65		65
66	extern char hostname[];	66	extern char hostname[];
67	extern void log (int level, const char *fmt, ...);	67	extern void _log (int level, const char *fmt, ...);
68	extern struct buffer *new_buf (int);	68	extern struct buffer *new_buf (int);
69	extern void udppush_handler (int);	69	extern void udppush_handler (int);
70	extern int addfcs (struct buffer *buf);	70	extern int addfcs (struct buffer *buf);




    server.sin_port = htons (gconfig.port);
    if ((server_socket = socket (PF_INET, SOCK_DGRAM, 0)) < 0)
    {
        _log (LOG_CRIT, "%s: Unable to allocate socket. Terminating.\n",
             __FUNCTION__);
        return -EINVAL;
    };

    if (bind (server_socket, (struct sockaddr *) &server, sizeof (server)))
    {
        close (server_socket);
        _log (LOG_CRIT, "%s: Unable to bind socket. Terminating.\n",
             __FUNCTION__);
        return -EINVAL;
    };
    if (getsockname (server_socket, (struct sockaddr *) &server, &length))
    {
        _log (LOG_CRIT, "%s: Unable to read socket name.Terminating.\n",
             __FUNCTION__);
        return -EINVAL;
    }
#ifdef USE_KERNEL
    if (gconfig.forceuserspace)
    {
        _log (LOG_LOG, "Not looking for kernel support.\n");
        kernel_support = 0;
    }
    else
    {
        if (ioctl (server_socket, SIOCSETL2TP, NULL) < 0)
        {
            _log (LOG_LOG, "L2TP kernel support not detected.\n");
            kernel_support = 0;
        }
        else
        {
            _log (LOG_LOG, "Using l2tp kernel support.\n");
            kernel_support = -1;
        }
    }
#else
    _log (LOG_LOG, "This binary does not support kernel L2TP.\n");
#endif
    arg = fcntl (server_socket, F_GETFL);
    arg |= O_NONBLOCK;

    int ns;
    if (!buf)
    {
        _log (LOG_WARN, "%s: called on NULL buffer!\n", __FUNCTION__);
        return;
    }


        if (ns < t->cLr)
        {
#ifdef DEBUG_CONTROL_XMIT
            _log (LOG_DEBUG, "%s: Tossing packet %d\n", __FUNCTION__, ns);
#endif
            /* Okay, it's been received.  Let's toss it now */
            toss (buf);

        {
            if (t->self->needclose)
            {
                _log (LOG_DEBUG,
                     "%s: Unable to deliver closing message for tunnel %d. Destroying anyway.\n",
                     __FUNCTION__, t->ourtid);
                t->self->needclose = 0;

            }
            else
            {
                _log (LOG_DEBUG,
                     "%s: Maximum retries exceeded for tunnel %d.  Closing.\n",
                     __FUNCTION__, t->ourtid);
                strcpy (t->self->errormsg, "Timeout");

        tv.tv_usec = 0;
        schedule (tv, control_xmit, buf);
#ifdef DEBUG_CONTROL_XMIT
        _log (LOG_DEBUG, "%s: Scheduling and transmitting packet %d\n",
             __FUNCTION__, ns);
#endif
        udp_xmit (buf);

            if (st->self->needclose ^ st->self->closing)
            {
                if (debug_tunnel)
                    _log (LOG_DEBUG, "%S: closing down tunnel %d\n",
                         __FUNCTION__, st->ourtid);
                call_close (st->self);
                /* Reset the while loop

                if (recvsize < 0)
                {
                    if (errno != EAGAIN)
                        _log (LOG_WARN,
                             "%s: recvfrom returned error %d (%s)\n",
                             __FUNCTION__, errno, strerror (errno));
                }
                else
                {
                    _log (LOG_WARN, "%s: received too small a packet\n",
                         __FUNCTION__);
                }
            }

                extract (buf->start, &tunnel, &call);
                if (debug_network)
                {
                    _log (LOG_DEBUG, "%s: recv packet from %s, size = %d,\n\
tunnel = %d, call = %d\n", __FUNCTION__, inet_ntoa (from.sin_addr), recvsize, tunnel, call);
                }
                if (packet_dump)

                         * to ack receiving the packet.
                         */
                        if (debug_tunnel)
                            _log (LOG_DEBUG,
                                 "%s: no such call %d on tunnel %d.  Sending special ZLB\n",
                                 __FUNCTION__);
                        handle_special (buf, c, call);
                    }
                    else
                        _log (LOG_DEBUG,
                             "%s: unable to find call or tunnel to handle packet.  call = %d, tunnel = %d Dumping.\n",
                             __FUNCTION__, call, tunnel);


                    if (handle_packet (buf, c->container, c))
                    {
                        if (debug_tunnel)
                            _log (LOG_DEBUG, "%s: bad packet\n", __FUNCTION__);
                    };
                    if (c->cnu)
                    {

                    int result;
                    recycle_payload (buf, sc->container->peer);
#ifdef DEBUG_FLOW_MORE
                    _log (LOG_DEBUG, "%s: rws = %d, pSs = %d, pLr = %d\n",
                         __FUNCTION__, sc->rws, sc->pSs, sc->pLr);
#endif
/*					if ((sc->rws>0) && (sc->pSs > sc->pLr + sc->rws) && !sc->rbit) {

                    }
                    if (result != 0)
                    {
                        _log (LOG_WARN,
                             "%s: tossing read packet, error = %s (%d).  Closing call.\n",
                             __FUNCTION__, strerror (-result), -result);
                        strcpy (sc->errormsg, strerror (-result));

Lines 57-62 Link Here

(-)l2tpd-0.69/pty.c (-1 / +1 lines)
57	}	57	}
58	}	58	}
59	}	59	}
60	log (LOG_CRIT, "%s: No more free pseudo-tty's\n", __FUNCTION__);	60	_log (LOG_CRIT, "%s: No more free pseudo-tty's\n", __FUNCTION__);
61	return -1;	61	return -1;
62	}	62	}

Lines 56-62 Link Here

(-)l2tpd-0.69/scheduler.c (-2 / +2 lines)
56	if (cnt != 1)	56	if (cnt != 1)
57	{	57	{
58	/* Whoa, we got called from within ourselves! */	58	/* Whoa, we got called from within ourselves! */
59	log (LOG_DEBUG, "%s : Whoa... cnt = %d\n", __FUNCTION__, cnt);	59	_log (LOG_DEBUG, "%s : Whoa... cnt = %d\n", __FUNCTION__, cnt);
60	return;	60	return;
61	}	61	}
62	while (events)	62	while (events)
Lines 89-95 Link Here
89	}	89	}
90	if ((then.tv_sec <= 0) && (then.tv_usec <= 0))	90	if ((then.tv_sec <= 0) && (then.tv_usec <= 0))
91	{	91	{
92	log (LOG_WARN, "%s: Whoa... Scheduling for <=0 time???\n",	92	_log (LOG_WARN, "%s: Whoa... Scheduling for <=0 time???\n",
93	__FUNCTION__);	93	__FUNCTION__);
94	}	94	}
95	else	95	else

Return to bug 40859

Lines 142-148 Link Here

(-)l2tpd-0.69/aaa.c (-23 / +23 lines)
142	f = fopen (gconfig.authfile, "r");	142	f = fopen (gconfig.authfile, "r");
143	if (!f)	143	if (!f)
144	{	144	{
145	log (LOG_WARN, "%s : Unable to open '%s' for authentication\n",	145	_log (LOG_WARN, "%s : Unable to open '%s' for authentication\n",
146	__FUNCTION__, gconfig.authfile);	146	__FUNCTION__, gconfig.authfile);
147	return 0;	147	return 0;
148	}	148	}
Lines 166-172 Link Here
166	/* us */	166	/* us */
167	if (!*u)	167	if (!*u)
168	{	168	{
169	log (LOG_WARN,	169	_log (LOG_WARN,
170	"%s: Invalid authentication info (no us), line %d\n",	170	"%s: Invalid authentication info (no us), line %d\n",
171	__FUNCTION__, num);	171	__FUNCTION__, num);
172	continue;	172	continue;
Lines 180-186 Link Here
180	/* them */	180	/* them */
181	if (!*t)	181	if (!*t)
182	{	182	{
183	log (LOG_WARN,	183	_log (LOG_WARN,
184	"%s: Invalid authentication info (nothem), line %d\n",	184	"%s: Invalid authentication info (nothem), line %d\n",
185	__FUNCTION__, num);	185	__FUNCTION__, num);
186	continue;	186	continue;
Lines 193-199 Link Here
193	s++;	193	s++;
194	if (!*s)	194	if (!*s)
195	{	195	{
196	log (LOG_WARN,	196	_log (LOG_WARN,
197	"%s: Invalid authentication info (no secret), line %d\n",	197	"%s: Invalid authentication info (no secret), line %d\n",
198	__FUNCTION__, num);	198	__FUNCTION__, num);
199	continue;	199	continue;
Lines 202-208 Link Here
202	(!strcasecmp (t, them) \|\| !strcasecmp (t, "*")))	202	(!strcasecmp (t, them) \|\| !strcasecmp (t, "*")))
203	{	203	{
204	#ifdef DEBUG_AUTH	204	#ifdef DEBUG_AUTH
205	log (LOG_DEBUG,	205	_log (LOG_DEBUG,
206	"%s: we are '%s', they are '%s', secret is '%s'\n",	206	"%s: we are '%s', they are '%s', secret is '%s'\n",
207	__FUNCTION__, u, t, s);	207	__FUNCTION__, u, t, s);
208	#endif	208	#endif
Lines 219-230 Link Here
219	char *them;	219	char *them;
220	if (!t->lns && !t->lac)	220	if (!t->lns && !t->lac)
221	{	221	{
222	log (LOG_DEBUG, "%s: No LNS or LAC to handle challenge!\n",	222	_log (LOG_DEBUG, "%s: No LNS or LAC to handle challenge!\n",
223	__FUNCTION__);	223	__FUNCTION__);
224	return -1;	224	return -1;
225	}	225	}
226	#ifdef DEBUG_AUTH	226	#ifdef DEBUG_AUTH
227	log (LOG_DEBUG, "%s: making response for tunnel: %d\n", __FUNCTION__,	227	_log (LOG_DEBUG, "%s: making response for tunnel: %d\n", __FUNCTION__,
228	t->ourtid);	228	t->ourtid);
229	#endif	229	#endif
230	if (t->lns)	230	if (t->lns)
Lines 251-269 Link Here
251	}	251	}
252	if (!get_secret (us, them, chal->secret, sizeof (chal->secret)))	252	if (!get_secret (us, them, chal->secret, sizeof (chal->secret)))
253	{	253	{
254	log (LOG_DEBUG, "%s: no secret found for us='%s' and them='%s'\n",	254	_log (LOG_DEBUG, "%s: no secret found for us='%s' and them='%s'\n",
255	__FUNCTION__, us, them);	255	__FUNCTION__, us, them);
256	return -1;	256	return -1;
257	}	257	}
258		258
259	#if DEBUG_AUTH	259	#if DEBUG_AUTH
260	log (LOG_DEBUG, "*%s: Here comes the chal->ss:\n", __FUNCTION__);	260	_log (LOG_DEBUG, "*%s: Here comes the chal->ss:\n", __FUNCTION__);
261	bufferDump (&chal->ss, 1);	261	bufferDump (&chal->ss, 1);
262		262
263	log (LOG_DEBUG, "%s: Here comes the secret\n", __FUNCTION__);	263	_log (LOG_DEBUG, "%s: Here comes the secret\n", __FUNCTION__);
264	bufferDump (chal->secret, strlen (chal->secret));	264	bufferDump (chal->secret, strlen (chal->secret));
265		265
266	log (LOG_DEBUG, "%s: Here comes the challenge\n", __FUNCTION__);	266	_log (LOG_DEBUG, "%s: Here comes the challenge\n", __FUNCTION__);
267	bufferDump (chal->challenge, strlen (chal->challenge));	267	bufferDump (chal->challenge, strlen (chal->challenge));
268	#endif	268	#endif
269		269
Lines 274-280 Link Here
274	MD5Update (&chal->md5, chal->challenge, strlen(chal->challenge));	274	MD5Update (&chal->md5, chal->challenge, strlen(chal->challenge));
275	MD5Final (chal->response, &chal->md5);	275	MD5Final (chal->response, &chal->md5);
276	#ifdef DEBUG_AUTH	276	#ifdef DEBUG_AUTH
277	log (LOG_DEBUG, "response is %X%X%X%X to '%s' and %X%X%X%X, %d\n",	277	_log (LOG_DEBUG, "response is %X%X%X%X to '%s' and %X%X%X%X, %d\n",
278	((int ) &chal->response[0]),	278	((int ) &chal->response[0]),
279	((int ) &chal->response[4]),	279	((int ) &chal->response[4]),
280	((int ) &chal->response[8]),	280	((int ) &chal->response[8]),
Lines 317-323 Link Here
317	(ntohl (t->peer.sin_addr.s_addr) <= ntohl (ipr->end)))	317	(ntohl (t->peer.sin_addr.s_addr) <= ntohl (ipr->end)))
318	{	318	{
319	#ifdef DEBUG_AAA	319	#ifdef DEBUG_AAA
320	log (LOG_DEBUG,	320	_log (LOG_DEBUG,
321	"get_lns: Rule %s to %s, sense %s matched %s\n",	321	"get_lns: Rule %s to %s, sense %s matched %s\n",
322	IPADDY (ipr->start), IPADDY (ipr->end),	322	IPADDY (ipr->start), IPADDY (ipr->end),
323	(ipr->sense ? "allow" : "deny"), IPADDY (t->addr));	323	(ipr->sense ? "allow" : "deny"), IPADDY (t->addr));
Lines 345-358 Link Here
345	void print_md5 (void *md5)	345	void print_md5 (void *md5)
346	{	346	{
347	int i = (int ) md5;	347	int i = (int ) md5;
348	log (LOG_DEBUG, "%X%X%X%X\n", i[0], i[1], i[2], i[3], i[4]);	348	_log (LOG_DEBUG, "%X%X%X%X\n", i[0], i[1], i[2], i[3], i[4]);
349	}	349	}
350		350
351	inline void print_challenge (struct challenge *chal)	351	inline void print_challenge (struct challenge *chal)
352	{	352	{
353	log (LOG_DEBUG, "vector: ");	353	_log (LOG_DEBUG, "vector: ");
354	print_md5 (chal->vector);	354	print_md5 (chal->vector);
355	log (LOG_DEBUG, "secret: %s\n", chal->secret);	355	_log (LOG_DEBUG, "secret: %s\n", chal->secret);
356	}	356	}
357	#endif	357	#endif
358	void encrypt_avp (struct buffer buf, _u16 len, struct tunnel t)	358	void encrypt_avp (struct buffer buf, _u16 len, struct tunnel t)
Lines 401-409 Link Here
401	while (ptr < end)	401	while (ptr < end)
402	{	402	{
403	#if DEBUG_HIDDEN	403	#if DEBUG_HIDDEN
404	log (LOG_DEBUG, "%s: The digest to be XOR'ed\n", __FUNCTION__);	404	_log (LOG_DEBUG, "%s: The digest to be XOR'ed\n", __FUNCTION__);
405	bufferDump (digest, MD_SIG_SIZE);	405	bufferDump (digest, MD_SIG_SIZE);
406	log (LOG_DEBUG, "%s: The plaintext to be XOR'ed\n", __FUNCTION__);	406	_log (LOG_DEBUG, "%s: The plaintext to be XOR'ed\n", __FUNCTION__);
407	bufferDump (ptr, MD_SIG_SIZE);	407	bufferDump (ptr, MD_SIG_SIZE);
408	#endif	408	#endif
409	for (cnt = 0; cnt < MD_SIG_SIZE; cnt++, ptr++)	409	for (cnt = 0; cnt < MD_SIG_SIZE; cnt++, ptr++)
Lines 411-417 Link Here
411	ptr = ptr ^ digest[cnt];	411	ptr = ptr ^ digest[cnt];
412	}	412	}
413	#if DEBUG_HIDDEN	413	#if DEBUG_HIDDEN
414	log (LOG_DEBUG, "%s: The result of XOR\n", __FUNCTION__);	414	_log (LOG_DEBUG, "%s: The result of XOR\n", __FUNCTION__);
415	bufferDump (previous_segment, MD_SIG_SIZE);	415	bufferDump (previous_segment, MD_SIG_SIZE);
416	#endif	416	#endif
417	if (ptr < end)	417	if (ptr < end)
Lines 445-451 Link Here
445	end = buf + olen;	445	end = buf + olen;
446	if (!t->chal_us.vector)	446	if (!t->chal_us.vector)
447	{	447	{
448	log (LOG_DEBUG,	448	_log (LOG_DEBUG,
449	"decrypt_avp: Hidden bit set, but no random vector specified!\n");	449	"decrypt_avp: Hidden bit set, but no random vector specified!\n");
450	return -EINVAL;	450	return -EINVAL;
451	}	451	}
Lines 460-468 Link Here
460	MD5Update (&t->chal_us.md5, t->chal_us.vector, t->chal_us.vector_len);	460	MD5Update (&t->chal_us.md5, t->chal_us.vector, t->chal_us.vector_len);
461	MD5Final (digest, &t->chal_us.md5);	461	MD5Final (digest, &t->chal_us.md5);
462	#ifdef DEBUG_HIDDEN	462	#ifdef DEBUG_HIDDEN
463	log (LOG_DEBUG, "attribute is %d and challenge is: ", attr);	463	_log (LOG_DEBUG, "attribute is %d and challenge is: ", attr);
464	print_challenge (&t->chal_us);	464	print_challenge (&t->chal_us);
465	log (LOG_DEBUG, "md5 is: ");	465	_log (LOG_DEBUG, "md5 is: ");
466	print_md5 (digest);	466	print_md5 (digest);
467	#endif	467	#endif
468	while (ptr < end)	468	while (ptr < end)
Lines 494-500 Link Here
494	len = ntohs (new_hdr->attr) + sizeof (struct avp_hdr);	494	len = ntohs (new_hdr->attr) + sizeof (struct avp_hdr);
495	if (len > olen - 2)	495	if (len > olen - 2)
496	{	496	{
497	log (LOG_DEBUG,	497	_log (LOG_DEBUG,
498	"decrypt_avp: Decrypted length is too long (%d > %d)\n", len,	498	"decrypt_avp: Decrypted length is too long (%d > %d)\n", len,
499	olen - 2);	499	olen - 2);
500	return -EINVAL;	500	return -EINVAL;

Lines 136-146 Link Here

(-)l2tpd-0.69/call.c (-20 / +20 lines)
136	return 0;	136	return 0;
137	}	137	}
138	errors++;	138	errors++;
139	log (LOG_DEBUG, "%s: Error %d (%s)\n", __FUNCTION__, errno,	139	_log (LOG_DEBUG, "%s: Error %d (%s)\n", __FUNCTION__, errno,
140	strerror (errno));	140	strerror (errno));
141	if (errors > 10)	141	if (errors > 10)
142	{	142	{
143	log (LOG_DEBUG,	143	_log (LOG_DEBUG,
144	"%s: Too many errors. Declaring call dead.\n",	144	"%s: Too many errors. Declaring call dead.\n",
145	__FUNCTION__);	145	__FUNCTION__);
146	return -errno;	146	return -errno;
Lines 152-158 Link Here
152	case PPP_FLAG:	152	case PPP_FLAG:
153	if (escape)	153	if (escape)
154	{	154	{
155	log (LOG_DEBUG, "%s: got an escaped PPP_FLAG\n",	155	_log (LOG_DEBUG, "%s: got an escaped PPP_FLAG\n",
156	__FUNCTION__);	156	__FUNCTION__);
157	return -EINVAL;	157	return -EINVAL;
158	}	158	}
Lines 188-199 Link Here
188	buf->len++;	188	buf->len++;
189	break;	189	break;
190	};	190	};
191	log (LOG_WARN, "%s: read overrun\n", __FUNCTION__);	191	_log (LOG_WARN, "%s: read overrun\n", __FUNCTION__);
192	return -EINVAL;	192	return -EINVAL;
193	}	193	}
194	}	194	}
195	/* I should never get here */	195	/* I should never get here */
196	log (LOG_WARN, "%s: You should not see this message. If you do, please	196	_log (LOG_WARN, "%s: You should not see this message. If you do, please\n\
197	enter a bug report at http://sourceforge.net/projects/l2tpd", __FUNCTION__);	197	enter a bug report at http://sourceforge.net/projects/l2tpd", __FUNCTION__);
198	return -EINVAL;	198	return -EINVAL;
199	}	199	}
Lines 205-211 Link Here
205	struct call tmp, tmp2;	205	struct call tmp, tmp2;
206	if (!c \|\| !c->container)	206	if (!c \|\| !c->container)
207	{	207	{
208	log (LOG_DEBUG, "%s: called on null call or containerless call\n",	208	_log (LOG_DEBUG, "%s: called on null call or containerless call\n",
209	__FUNCTION__);	209	__FUNCTION__);
210	return;	210	return;
211	}	211	}
Lines 229-235 Link Here
229	\|\| ((struct tunnel *) se->data == c->container))	229	\|\| ((struct tunnel *) se->data == c->container))
230	{	230	{
231	#ifdef DEBUG_CLOSE	231	#ifdef DEBUG_CLOSE
232	log (LOG_DEBUG, "%s: Descheduling event\n", __FUNCTION__);	232	_log (LOG_DEBUG, "%s: Descheduling event\n", __FUNCTION__);
233	#endif	233	#endif
234	if (ose)	234	if (ose)
235	{	235	{
Lines 260-266 Link Here
260	/* Really close this tunnel, as our	260	/* Really close this tunnel, as our
261	StopCCN has been ack'd */	261	StopCCN has been ack'd */
262	#ifdef DEBUG_CLOSE	262	#ifdef DEBUG_CLOSE
263	log (LOG_DEBUG, "%s: Actually closing tunnel %d\n", __FUNCTION__,	263	_log (LOG_DEBUG, "%s: Actually closing tunnel %d\n", __FUNCTION__,
264	c->container->ourtid);	264	c->container->ourtid);
265	#endif	265	#endif
266	#ifdef USE_KERNEL	266	#ifdef USE_KERNEL
Lines 296-302 Link Here
296	if (packet_dump)	296	if (packet_dump)
297	do_packet_dump (buf);	297	do_packet_dump (buf);
298	#ifdef DEBUG_CLOSE	298	#ifdef DEBUG_CLOSE
299	log (LOG_DEBUG, "%s: enqueing close message for tunnel\n",	299	_log (LOG_DEBUG, "%s: enqueing close message for tunnel\n",
300	__FUNCTION__);	300	__FUNCTION__);
301	#endif	301	#endif
302	control_xmit (buf);	302	control_xmit (buf);
Lines 313-319 Link Here
313	call_close (tmp);	313	call_close (tmp);
314	tmp = tmp2;	314	tmp = tmp2;
315	}	315	}
316	log (LOG_LOG,	316	_log (LOG_LOG,
317	"%s : Connection %d closed to %s, port %d (%s)\n", __FUNCTION__,	317	"%s : Connection %d closed to %s, port %d (%s)\n", __FUNCTION__,
318	c->container->tid,	318	c->container->tid,
319	IPADDY (c->container->peer.sin_addr),	319	IPADDY (c->container->peer.sin_addr),
Lines 333-339 Link Here
333	if (c->closing)	333	if (c->closing)
334	{	334	{
335	#ifdef DEBUG_CLOSE	335	#ifdef DEBUG_CLOSE
336	log (LOG_DEBUG, "%s: Actually closing call %d\n", __FUNCTION__,	336	_log (LOG_DEBUG, "%s: Actually closing call %d\n", __FUNCTION__,
337	c->ourcid);	337	c->ourcid);
338	#endif	338	#endif
339	destroy_call (c);	339	destroy_call (c);
Lines 373-383 Link Here
373	if (packet_dump)	373	if (packet_dump)
374	do_packet_dump (buf);	374	do_packet_dump (buf);
375	#ifdef DEBUG_CLOSE	375	#ifdef DEBUG_CLOSE
376	log (LOG_DEBUG, "%s: enqueuing close message for call %d\n",	376	_log (LOG_DEBUG, "%s: enqueuing close message for call %d\n",
377	__FUNCTION__, c->ourcid);	377	__FUNCTION__, c->ourcid);
378	#endif	378	#endif
379	control_xmit (buf);	379	control_xmit (buf);
380	log (LOG_LOG, "%s: Call %d to %s disconnected\n", __FUNCTION__,	380	_log (LOG_LOG, "%s: Call %d to %s disconnected\n", __FUNCTION__,
381	c->ourcid, IPADDY (c->container->peer.sin_addr));	381	c->ourcid, IPADDY (c->container->peer.sin_addr));
382	}	382	}
383	/*	383	/*
Lines 461-467 Link Here
461	c->lac->active)	461	c->lac->active)
462	{	462	{
463	#ifdef DEBUG_MAGIC	463	#ifdef DEBUG_MAGIC
464	log (LOG_LOG, "%s: Will redial in %d seconds\n", __FUNCTION__,	464	_log (LOG_LOG, "%s: Will redial in %d seconds\n", __FUNCTION__,
465	c->lac->rtimeout);	465	c->lac->rtimeout);
466	#endif	466	#endif
467	tv.tv_sec = c->lac->rtimeout;	467	tv.tv_sec = c->lac->rtimeout;
Lines 517-523 Link Here
517	temp = (int *)entropy_buf;	517	temp = (int *)entropy_buf;
518	tmp->ourcid = *temp & 0xFFFF;	518	tmp->ourcid = *temp & 0xFFFF;
519	#ifdef DEBUG_ENTROPY	519	#ifdef DEBUG_ENTROPY
520	log(LOG_DEBUG, "ourcid = %u, entropy_buf = %hx\n", tmp->ourcid, *temp);	520	_log(LOG_DEBUG, "ourcid = %u, entropy_buf = %hx\n", tmp->ourcid, *temp);
521	#endif	521	#endif
522	}	522	}
523	#else	523	#else
Lines 606-612 Link Here
606	return sc;	606	return sc;
607	sc = sc->next;	607	sc = sc->next;
608	}	608	}
609	log (LOG_DEBUG, "%s: can't find call %d in tunnel %d\n",	609	_log (LOG_DEBUG, "%s: can't find call %d in tunnel %d\n",
610	__FUNCTION__, call, tunnel);	610	__FUNCTION__, call, tunnel);
611	return NULL;	611	return NULL;
612	}	612	}
Lines 617-623 Link Here
617	}	617	}
618	st = st->next;	618	st = st->next;
619	}	619	}
620	log (LOG_DEBUG, "%s:can't find tunnel %d\n", __FUNCTION__, tunnel);	620	_log (LOG_DEBUG, "%s:can't find tunnel %d\n", __FUNCTION__, tunnel);
621	return NULL;	621	return NULL;
622	}	622	}
623	else	623	else
Lines 630-636 Link Here
630		630
631	if (call)	631	if (call)
632	{	632	{
633	log (LOG_WARN,	633	_log (LOG_WARN,
634	"%s: call ID specified, but no tunnel ID specified. tossing.\n",	634	"%s: call ID specified, but no tunnel ID specified. tossing.\n",
635	__FUNCTION__);	635	__FUNCTION__);
636	return NULL;	636	return NULL;
Lines 641-653 Link Here
641	*/	641	*/
642	if (debug_tunnel)	642	if (debug_tunnel)
643	{	643	{
644	log (LOG_DEBUG,	644	_log (LOG_DEBUG,
645	"%s: allocating new tunnel for host %s, port %d.\n",	645	"%s: allocating new tunnel for host %s, port %d.\n",
646	__FUNCTION__, IPADDY (addr), ntohs (port));	646	__FUNCTION__, IPADDY (addr), ntohs (port));
647	}	647	}
648	if (!(st = new_tunnel ()))	648	if (!(st = new_tunnel ()))
649	{	649	{
650	log (LOG_WARN,	650	_log (LOG_WARN,
651	"%s: unable to allocate new tunnel for host %s, port %d.\n",	651	"%s: unable to allocate new tunnel for host %s, port %d.\n",
652	__FUNCTION__, IPADDY (addr), ntohs (port));	652	__FUNCTION__, IPADDY (addr), ntohs (port));
653	return NULL;	653	return NULL;

Lines 30-36 Link Here

(-)l2tpd-0.69/misc.c (-7 / +7 lines)
30	#include "l2tp.h"	30	#include "l2tp.h"
31		31
32		32
33	void log (int level, const char *fmt, ...)	33	void _log (int level, const char *fmt, ...)
34	{	34	{
35	char buf[256];	35	char buf[256];
36	va_list args;	36	va_list args;
Lines 99-105 Link Here
99	c++; /* again two characters to display ONE byte */	99	c++; /* again two characters to display ONE byte */
100	}	100	}
101	*c = '\0';	101	*c = '\0';
102	log (LOG_WARN, "%s: buflen=%d, buffer[%d]: %s\n", __FUNCTION__,	102	_log (LOG_WARN, "%s: buflen=%d, buffer[%d]: %s\n", __FUNCTION__,
103	buflen, i, line);	103	buflen, i, line);
104	}	104	}
105		105
Lines 115-121 Link Here
115	if (c != line)	115	if (c != line)
116	{	116	{
117	*c = '\0';	117	*c = '\0';
118	log (LOG_WARN, "%s: buffer[%d]: %s\n", __FUNCTION__, i,	118	_log (LOG_WARN, "%s: buffer[%d]: %s\n", __FUNCTION__, i,
119	line);	119	line);
120	}	120	}
121	}	121	}
Lines 199-205 Link Here
199	new = (struct ppp_opts *) malloc (sizeof (struct ppp_opts));	199	new = (struct ppp_opts *) malloc (sizeof (struct ppp_opts));
200	if (!new)	200	if (!new)
201	{	201	{
202	log (LOG_WARN,	202	_log (LOG_WARN,
203	"%s : Unable to allocate ppp option memory. Expect a crash\n",	203	"%s : Unable to allocate ppp option memory. Expect a crash\n",
204	__FUNCTION__);	204	__FUNCTION__);
205	return NULL;	205	return NULL;
Lines 265-271 Link Here
265	if (devrandom == -1)	265	if (devrandom == -1)
266	{	266	{
267	#ifdef DEBUG_ENTROPY	267	#ifdef DEBUG_ENTROPY
268	log(LOG_WARN, "%s: couldn't open /dev/urandom,"	268	_log(LOG_WARN, "%s: couldn't open /dev/urandom,"
269	"falling back to rand()\n",	269	"falling back to rand()\n",
270	__FUNCTION__);	270	__FUNCTION__);
271	#endif	271	#endif
Lines 288-300 Link Here
288	}	288	}
289	else if (rand_source == RAND_EGD)	289	else if (rand_source == RAND_EGD)
290	{	290	{
291	log(LOG_WARN, "%s: EGD Randomness source not yet implemented\n",	291	_log(LOG_WARN, "%s: EGD Randomness source not yet implemented\n",
292	__FUNCTION__);	292	__FUNCTION__);
293	return -1;	293	return -1;
294	}	294	}
295	else	295	else
296	{	296	{
297	log(LOG_WARN, "%s: Invalid Randomness source specified (%d)\n",	297	_log(LOG_WARN, "%s: Invalid Randomness source specified (%d)\n",
298	__FUNCTION__, rand_source);	298	__FUNCTION__, rand_source);
299	return -1;	299	return -1;
300	}	300	}

Lines 56-62 Link Here

(-)l2tpd-0.69/file.c (-27 / +27 lines)
56	}	56	}
57	else	57	else
58	{	58	{
59	log (LOG_CRIT, "%s: Unable to open config file %s or %s\n",	59	_log (LOG_CRIT, "%s: Unable to open config file %s or %s\n",
60	__FUNCTION__, gconfig.configfile, gconfig.altconfigfile);	60	__FUNCTION__, gconfig.configfile, gconfig.altconfigfile);
61	return -1;	61	return -1;
62	}	62	}
Lines 74-80 Link Here
74	tmp = (struct lns *) malloc (sizeof (struct lns));	74	tmp = (struct lns *) malloc (sizeof (struct lns));
75	if (!tmp)	75	if (!tmp)
76	{	76	{
77	log (LOG_CRIT, "%s: Unable to allocate memory for new LNS\n",	77	_log (LOG_CRIT, "%s: Unable to allocate memory for new LNS\n",
78	__FUNCTION__);	78	__FUNCTION__);
79	return NULL;	79	return NULL;
80	}	80	}
Lines 118-124 Link Here
118	tmp = (struct lac *) malloc (sizeof (struct lac));	118	tmp = (struct lac *) malloc (sizeof (struct lac));
119	if (!tmp)	119	if (!tmp)
120	{	120	{
121	log (LOG_CRIT, "%s: Unable to allocate memory for lac entry!\n",	121	_log (LOG_CRIT, "%s: Unable to allocate memory for lac entry!\n",
122	__FUNCTION__);	122	__FUNCTION__);
123	return NULL;	123	return NULL;
124	}	124	}
Lines 171-177 Link Here
171	{	171	{
172	int val;	172	int val;
173	#ifdef DEBUG_FILE	173	#ifdef DEBUG_FILE
174	log (LOG_DEBUG, "set_%s: %s flag to '%s'\n", word, word, value);	174	_log (LOG_DEBUG, "set_%s: %s flag to '%s'\n", word, word, value);
175	#endif /* ; */	175	#endif /* ; */
176	if ((val = yesno (value)) < 0)	176	if ((val = yesno (value)) < 0)
177	{	177	{
Lines 187-193 Link Here
187	{	187	{
188	int val;	188	int val;
189	#ifdef DEBUG_FILE	189	#ifdef DEBUG_FILE
190	log (LOG_DEBUG, "set_%s: %s flag to '%s'\n", word, word, value);	190	_log (LOG_DEBUG, "set_%s: %s flag to '%s'\n", word, word, value);
191	#endif /* ; */	191	#endif /* ; */
192	if ((val = atoi (value)) < 0)	192	if ((val = atoi (value)) < 0)
193	{	193	{
Lines 201-207 Link Here
201	int set_string (char word, char value, char *ptr, int len)	201	int set_string (char word, char value, char *ptr, int len)
202	{	202	{
203	#ifdef DEBUG_FILE	203	#ifdef DEBUG_FILE
204	log (LOG_DEBUG, "set_%s: %s flag to '%s'\n", word, word, value);	204	_log (LOG_DEBUG, "set_%s: %s flag to '%s'\n", word, word, value);
205	#endif /* ; */	205	#endif /* ; */
206	strncpy (ptr, value, len);	206	strncpy (ptr, value, len);
207	return 0;	207	return 0;
Lines 213-219 Link Here
213	{	213	{
214	case CONTEXT_GLOBAL:	214	case CONTEXT_GLOBAL:
215	#ifdef DEBUG_FILE	215	#ifdef DEBUG_FILE
216	log (LOG_DEBUG, "set_port: Setting global port number to %s\n",	216	_log (LOG_DEBUG, "set_port: Setting global port number to %s\n",
217	value);	217	value);
218	#endif	218	#endif
219	set_int (word, value, &(((struct global *) item)->port));	219	set_int (word, value, &(((struct global *) item)->port));
Lines 238-244 Link Here
238	{	238	{
239	case CONTEXT_LAC:	239	case CONTEXT_LAC:
240	#ifdef DEBUG_FILE	240	#ifdef DEBUG_FILE
241	log (LOG_DEBUG, "set_rtimeout: Setting redial timeout to %s\n",	241	_log (LOG_DEBUG, "set_rtimeout: Setting redial timeout to %s\n",
242	value);	242	value);
243	#endif	243	#endif
244	set_int (word, value, &(((struct lac *) item)->rtimeout));	244	set_int (word, value, &(((struct lac *) item)->rtimeout));
Lines 308-314 Link Here
308	{	308	{
309	case CONTEXT_LAC:	309	case CONTEXT_LAC:
310	#ifdef DEBUG_FILE	310	#ifdef DEBUG_FILE
311	log (LOG_DEBUG, "set_rmax: Setting max redials to %s\n", value);	311	_log (LOG_DEBUG, "set_rmax: Setting max redials to %s\n", value);
312	#endif	312	#endif
313	set_int (word, value, &(((struct lac *) item)->rmax));	313	set_int (word, value, &(((struct lac *) item)->rmax));
314	break;	314	break;
Lines 332-338 Link Here
332	{	332	{
333	case CONTEXT_GLOBAL:	333	case CONTEXT_GLOBAL:
334	#ifdef DEBUG_FILE	334	#ifdef DEBUG_FILE
335	log (LOG_DEBUG, "set_authfile: Setting global auth file to '%s'\n",	335	_log (LOG_DEBUG, "set_authfile: Setting global auth file to '%s'\n",
336	value);	336	value);
337	#endif /* ; */	337	#endif /* ; */
338	strncpy (((struct global *) item)->authfile, value,	338	strncpy (((struct global *) item)->authfile, value,
Lines 763-769 Link Here
763	if (!lns->range)	763	if (!lns->range)
764	return -1;	764	return -1;
765	#ifdef DEBUG_FILE	765	#ifdef DEBUG_FILE
766	log (LOG_DEBUG, "range start = %x, end = %x, sense=%ud\n",	766	_log (LOG_DEBUG, "range start = %x, end = %x, sense=%ud\n",
767	ntohl (ipr->start), ntohl (ipr->end), ipr->sense);	767	ntohl (ipr->start), ntohl (ipr->end), ipr->sense);
768	#endif	768	#endif
769	return 0;	769	return 0;
Lines 785-791 Link Here
785	if (!lns->lacs)	785	if (!lns->lacs)
786	return -1;	786	return -1;
787	#ifdef DEBUG_FILE	787	#ifdef DEBUG_FILE
788	log (LOG_DEBUG, "lac start = %x, end = %x, sense=%ud\n",	788	_log (LOG_DEBUG, "lac start = %x, end = %x, sense=%ud\n",
789	ntohl (ipr->start), ntohl (ipr->end), ipr->sense);	789	ntohl (ipr->start), ntohl (ipr->end), ipr->sense);
790	#endif	790	#endif
791	return 0;	791	return 0;
Lines 867-873 Link Here
867	{	867	{
868	case CONTEXT_LAC:	868	case CONTEXT_LAC:
869	#ifdef DEBUG_FILE	869	#ifdef DEBUG_FILE
870	log (LOG_DEBUG, "set_lns: setting LNS to '%s'\n", value);	870	_log (LOG_DEBUG, "set_lns: setting LNS to '%s'\n", value);
871	#endif	871	#endif
872	l = (struct lac *) item;	872	l = (struct lac *) item;
873	d = strchr (value, ':');	873	d = strchr (value, ':');
Lines 911-917 Link Here
911		911
912	int set_rand_sys ()	912	int set_rand_sys ()
913	{	913	{
914	log(LOG_WARN, "The \"rand()\" function call is not a very good source"	914	_log(LOG_WARN, "The \"rand()\" function call is not a very good source"
915	"of randomness\n");	915	"of randomness\n");
916	rand_source = RAND_SYS;	916	rand_source = RAND_SYS;
917	return 0;	917	return 0;
Lines 925-931 Link Here
925		925
926	int set_rand_egd (char *value)	926	int set_rand_egd (char *value)
927	{	927	{
928	log(LOG_WARN, "%s: not yet implemented!\n", __FUNCTION__);	928	_log(LOG_WARN, "%s: not yet implemented!\n", __FUNCTION__);
929	rand_source = RAND_EGD;	929	rand_source = RAND_EGD;
930	return -1;	930	return -1;
931	}	931	}
Lines 953-959 Link Here
953		953
954	if (context != CONTEXT_GLOBAL)	954	if (context != CONTEXT_GLOBAL)
955	{	955	{
956	log(LOG_WARN, "%s: %s not valid in context %d\n",	956	_log(LOG_WARN, "%s: %s not valid in context %d\n",
957	__FUNCTION__, word, context);	957	__FUNCTION__, word, context);
958	return -1;	958	return -1;
959	}	959	}
Lines 977-983 Link Here
977	}	977	}
978	else	978	else
979	{	979	{
980	log(LOG_WARN, "%s: %s is not a valid randomness source\n",	980	_log(LOG_WARN, "%s: %s is not a valid randomness source\n",
981	__FUNCTION__, value);	981	__FUNCTION__, value);
982	return -1;	982	return -1;
983		983
Lines 1023-1029 Link Here
1023	/* We've got a context description */	1023	/* We've got a context description */
1024	if (!(t = strchr (s, ']')))	1024	if (!(t = strchr (s, ']')))
1025	{	1025	{
1026	log (LOG_CRIT, "parse_config: line %d: No closing bracket\n",	1026	_log (LOG_CRIT, "parse_config: line %d: No closing bracket\n",
1027	linenum);	1027	linenum);
1028	return -1;	1028	return -1;
1029	}	1029	}
Lines 1043-1049 Link Here
1043	{	1043	{
1044	context = CONTEXT_GLOBAL;	1044	context = CONTEXT_GLOBAL;
1045	#ifdef DEBUG_FILE	1045	#ifdef DEBUG_FILE
1046	log (LOG_DEBUG,	1046	_log (LOG_DEBUG,
1047	"parse_config: global context descriptor %s\n",	1047	"parse_config: global context descriptor %s\n",
1048	d ? d : "");	1048	d ? d : "");
1049	#endif	1049	#endif
Lines 1088-1094 Link Here
1088	strncpy (((struct lns *) data)->entname,	1088	strncpy (((struct lns *) data)->entname,
1089	d, sizeof (((struct lns *) data)->entname));	1089	d, sizeof (((struct lns *) data)->entname));
1090	#ifdef DEBUG_FILE	1090	#ifdef DEBUG_FILE
1091	log (LOG_DEBUG, "parse_config: lns context descriptor %s\n",	1091	_log (LOG_DEBUG, "parse_config: lns context descriptor %s\n",
1092	d ? d : "");	1092	d ? d : "");
1093	#endif	1093	#endif
1094	}	1094	}
Lines 1131-1143 Link Here
1131	strncpy (((struct lac *) data)->entname,	1131	strncpy (((struct lac *) data)->entname,
1132	d, sizeof (((struct lac *) data)->entname));	1132	d, sizeof (((struct lac *) data)->entname));
1133	#ifdef DEBUG_FILE	1133	#ifdef DEBUG_FILE
1134	log (LOG_DEBUG, "parse_config: lac context descriptor %s\n",	1134	_log (LOG_DEBUG, "parse_config: lac context descriptor %s\n",
1135	d ? d : "");	1135	d ? d : "");
1136	#endif	1136	#endif
1137	}	1137	}
1138	else	1138	else
1139	{	1139	{
1140	log (LOG_WARN,	1140	_log (LOG_WARN,
1141	"parse_config: line %d: unknown context '%s'\n", linenum,	1141	"parse_config: line %d: unknown context '%s'\n", linenum,
1142	s);	1142	s);
1143	return -1;	1143	return -1;
Lines 1147-1160 Link Here
1147	{	1147	{
1148	if (!context)	1148	if (!context)
1149	{	1149	{
1150	log (LOG_WARN,	1150	_log (LOG_WARN,
1151	"parse_config: line %d: data '%s' occurs with no context\n",	1151	"parse_config: line %d: data '%s' occurs with no context\n",
1152	linenum, s);	1152	linenum, s);
1153	return -1;	1153	return -1;
1154	}	1154	}
1155	if (!(t = strchr (s, '=')))	1155	if (!(t = strchr (s, '=')))
1156	{	1156	{
1157	log (LOG_WARN, "parse_config: line %d: no '=' in data\n",	1157	_log (LOG_WARN, "parse_config: line %d: no '=' in data\n",
1158	linenum);	1158	linenum);
1159	return -1;	1159	return -1;
1160	}	1160	}
Lines 1168-1174 Link Here
1168	while (t && (t < 33))	1168	while (t && (t < 33))
1169	t++;	1169	t++;
1170	#ifdef DEBUG_FILE	1170	#ifdef DEBUG_FILE
1171	log (LOG_DEBUG, "parse_config: field is %s, value is %s\n", s, t);	1171	_log (LOG_DEBUG, "parse_config: field is %s, value is %s\n", s, t);
1172	#endif	1172	#endif
1173	/* Okay, bit twidling is done. Let's handle this */	1173	/* Okay, bit twidling is done. Let's handle this */
1174	for (kw = words; kw->keyword; kw++)	1174	for (kw = words; kw->keyword; kw++)
Lines 1177-1183 Link Here
1177	{	1177	{
1178	if (kw->handler (s, t, context \| def, data))	1178	if (kw->handler (s, t, context \| def, data))
1179	{	1179	{
1180	log (LOG_WARN, "parse_config: line %d: %s", linenum,	1180	_log (LOG_WARN, "parse_config: line %d: %s", linenum,
1181	filerr);	1181	filerr);
1182	return -1;	1182	return -1;
1183	}	1183	}
Lines 1186-1192 Link Here
1186	}	1186	}
1187	if (!kw->keyword)	1187	if (!kw->keyword)
1188	{	1188	{
1189	log (LOG_CRIT, "parse_config: line %d: Unknown field '%s'\n",	1189	_log (LOG_CRIT, "parse_config: line %d: Unknown field '%s'\n",
1190	linenum, s);	1190	linenum, s);
1191	return -1;	1191	return -1;
1192	}	1192	}

Lines 71-77 Link Here

(-)l2tpd-0.69/l2tpd.c (-57 / +57 lines)
71	FILE *f = fdopen (fd2, "a");	71	FILE *f = fdopen (fd2, "a");
72	if (!f)	72	if (!f)
73	{	73	{
74	log (LOG_WARN, "show_status: fdopen() failed on fd %d\n", fd);	74	_log (LOG_WARN, "show_status: fdopen() failed on fd %d\n", fd);
75	return;	75	return;
76	}	76	}
77	fprintf (f, "====== l2tpd statistics ========\n");	77	fprintf (f, "====== l2tpd statistics ========\n");
Lines 207-213 Link Here
207	{	207	{
208	if (c->pppd == pid)	208	if (c->pppd == pid)
209	{	209	{
210	log (LOG_DEBUG, "%s : pppd died for call %d\n", __FUNCTION__,	210	_log (LOG_DEBUG, "%s : pppd died for call %d\n", __FUNCTION__,
211	c->cid);	211	c->cid);
212	c->needclose = -1;	212	c->needclose = -1;
213	/*	213	/*
Lines 233-239 Link Here
233	*/	233	*/
234	struct tunnel st, st2;	234	struct tunnel st, st2;
235	int sec;	235	int sec;
236	log (LOG_CRIT, "%s: Fatal signal %d received\n", __FUNCTION__, signal);	236	_log (LOG_CRIT, "%s: Fatal signal %d received\n", __FUNCTION__, signal);
237	st = tunnels.head;	237	st = tunnels.head;
238	while (st)	238	while (st)
239	{	239	{
Lines 285-296 Link Here
285	stropt[pos] = NULL;	285	stropt[pos] = NULL;
286	if (c->pppd > 0)	286	if (c->pppd > 0)
287	{	287	{
288	log (LOG_WARN, "%s: PPP already started on call!\n", __FUNCTION__);	288	_log (LOG_WARN, "%s: PPP already started on call!\n", __FUNCTION__);
289	return -EINVAL;	289	return -EINVAL;
290	}	290	}
291	if (c->fd > -1)	291	if (c->fd > -1)
292	{	292	{
293	log (LOG_WARN, "%s: file descriptor already assigned!\n",	293	_log (LOG_WARN, "%s: file descriptor already assigned!\n",
294	__FUNCTION__);	294	__FUNCTION__);
295	return -EINVAL;	295	return -EINVAL;
296	}	296	}
Lines 311-317 Link Here
311	#endif	311	#endif
312	if ((c->fd = getPtyMaster (&a, &b)) < 0)	312	if ((c->fd = getPtyMaster (&a, &b)) < 0)
313	{	313	{
314	log (LOG_WARN, "%s: unable to allocate pty, abandoning!\n",	314	_log (LOG_WARN, "%s: unable to allocate pty, abandoning!\n",
315	__FUNCTION__);	315	__FUNCTION__);
316	return -EINVAL;	316	return -EINVAL;
317	}	317	}
Lines 331-347 Link Here
331	#endif	331	#endif
332	str = stropt[0];	332	str = stropt[0];
333	#ifdef DEBUG_PPPD	333	#ifdef DEBUG_PPPD
334	log (LOG_DEBUG, "%s: I'm running: ", __FUNCTION__);	334	_log (LOG_DEBUG, "%s: I'm running: ", __FUNCTION__);
335	for (x = 0; stropt[x]; x++)	335	for (x = 0; stropt[x]; x++)
336	{	336	{
337	log (LOG_DEBUG, "\"%s\" ", stropt[x]);	337	_log (LOG_DEBUG, "\"%s\" ", stropt[x]);
338	};	338	};
339	log (LOG_DEBUG, "\n");	339	_log (LOG_DEBUG, "\n");
340	#endif	340	#endif
341	c->pppd = fork ();	341	c->pppd = fork ();
342	if (c->pppd < 0)	342	if (c->pppd < 0)
343	{	343	{
344	log (LOG_WARN, "%s: unable to fork(), abandoning!\n", __FUNCTION__);	344	_log (LOG_WARN, "%s: unable to fork(), abandoning!\n", __FUNCTION__);
345	return -EINVAL;	345	return -EINVAL;
346	}	346	}
347	else if (!c->pppd)	347	else if (!c->pppd)
Lines 358-364 Link Here
358	if (fd2 < 0)	358	if (fd2 < 0)
359	#endif	359	#endif
360	{	360	{
361	log (LOG_WARN, "%s: Unable to open %s to launch pppd!\n",	361	_log (LOG_WARN, "%s: Unable to open %s to launch pppd!\n",
362	__FUNCTION__, tty);	362	__FUNCTION__, tty);
363	exit (1);	363	exit (1);
364	}	364	}
Lines 386-392 Link Here
386	close (control_fd);	386	close (control_fd);
387		387
388	execv (PPPD, stropt);	388	execv (PPPD, stropt);
389	log (LOG_WARN, "%s: Exec of %s failed!\n", __FUNCTION__, PPPD);	389	_log (LOG_WARN, "%s: Exec of %s failed!\n", __FUNCTION__, PPPD);
390	exit (1);	390	exit (1);
391	};	391	};
392	close (fd2);	392	close (fd2);
Lines 455-468 Link Here
455	}	455	}
456	else	456	else
457	{	457	{
458	log (LOG_WARN,	458	_log (LOG_WARN,
459	"%s: unable to locate tunnel in tunnel list\n",	459	"%s: unable to locate tunnel in tunnel list\n",
460	__FUNCTION__);	460	__FUNCTION__);
461	}	461	}
462	}	462	}
463	else	463	else
464	{	464	{
465	log (LOG_WARN, "%s: tunnel list is empty!\n", __FUNCTION__);	465	_log (LOG_WARN, "%s: tunnel list is empty!\n", __FUNCTION__);
466	}	466	}
467	}	467	}
468	if (t->lac)	468	if (t->lac)
Lines 471-477 Link Here
471	if (t->lac->redial && (t->lac->rtimeout > 0) && !t->lac->rsched &&	471	if (t->lac->redial && (t->lac->rtimeout > 0) && !t->lac->rsched &&
472	t->lac->active)	472	t->lac->active)
473	{	473	{
474	log (LOG_LOG, "%s: Will redial in %d seconds\n", __FUNCTION__,	474	_log (LOG_LOG, "%s: Will redial in %d seconds\n", __FUNCTION__,
475	t->lac->rtimeout);	475	t->lac->rtimeout);
476	tv.tv_sec = t->lac->rtimeout;	476	tv.tv_sec = t->lac->rtimeout;
477	tv.tv_usec = 0;	477	tv.tv_usec = 0;
Lines 501-507 Link Here
501	hp = gethostbyname (host);	501	hp = gethostbyname (host);
502	if (!hp)	502	if (!hp)
503	{	503	{
504	log (LOG_WARN, "%s: gethostbyname() failed for %s.\n", __FUNCTION__,	504	_log (LOG_WARN, "%s: gethostbyname() failed for %s.\n", __FUNCTION__,
505	host);	505	host);
506	return NULL;	506	return NULL;
507	}	507	}
Lines 514-520 Link Here
514	tmp = get_call (0, 0, addr, port);	514	tmp = get_call (0, 0, addr, port);
515	if (!tmp)	515	if (!tmp)
516	{	516	{
517	log (LOG_WARN, "%s: Unable to create tunnel to %s.\n", __FUNCTION__,	517	_log (LOG_WARN, "%s: Unable to create tunnel to %s.\n", __FUNCTION__,
518	host);	518	host);
519	return NULL;	519	return NULL;
520	}	520	}
Lines 530-536 Link Here
530	/*	530	/*
531	* Since our state is 0, we will establish a tunnel now	531	* Since our state is 0, we will establish a tunnel now
532	*/	532	*/
533	log (LOG_LOG, "%s:Connecting to host %s, port %d\n", __FUNCTION__, host,	533	_log (LOG_LOG, "%s:Connecting to host %s, port %d\n", __FUNCTION__, host,
534	ntohs (port));	534	ntohs (port));
535	control_finish (tmp->container, tmp);	535	control_finish (tmp->container, tmp);
536	return tmp->container;	536	return tmp->container;
Lines 542-548 Link Here
542	lac = (struct lac *) data;	542	lac = (struct lac *) data;
543	if (!lac)	543	if (!lac)
544	{	544	{
545	log (LOG_WARN, "%s: magic_lac_tunnel: called on NULL lac!\n",	545	_log (LOG_WARN, "%s: magic_lac_tunnel: called on NULL lac!\n",
546	__FUNCTION__);	546	__FUNCTION__);
547	return;	547	return;
548	}	548	}
Lines 559-565 Link Here
559	}	559	}
560	else	560	else
561	{	561	{
562	log (LOG_WARN, "%s: Unable to find hostname to dial for '%s'\n",	562	_log (LOG_WARN, "%s: Unable to find hostname to dial for '%s'\n",
563	__FUNCTION__, lac->entname);	563	__FUNCTION__, lac->entname);
564	return;	564	return;
565	}	565	}
Lines 576-582 Link Here
576	tmp = new_call (t);	576	tmp = new_call (t);
577	if (!tmp)	577	if (!tmp)
578	{	578	{
579	log (LOG_WARN, "%s: unable to create new call\n",	579	_log (LOG_WARN, "%s: unable to create new call\n",
580	__FUNCTION__);	580	__FUNCTION__);
581	return NULL;	581	return NULL;
582	}	582	}
Lines 588-601 Link Here
588	tmp->lns = lns;	588	tmp->lns = lns;
589	if (lac)	589	if (lac)
590	lac->c = tmp;	590	lac->c = tmp;
591	log (LOG_LOG, "%s: Calling on tunnel %d\n", __FUNCTION__, tid);	591	_log (LOG_LOG, "%s: Calling on tunnel %d\n", __FUNCTION__, tid);
592	strcpy (tmp->dial_no, dial_no_tmp); /* jz: copy dialnumber to tmp->dial_no */	592	strcpy (tmp->dial_no, dial_no_tmp); /* jz: copy dialnumber to tmp->dial_no */
593	control_finish (t, tmp);	593	control_finish (t, tmp);
594	return tmp;	594	return tmp;
595	}	595	}
596	t = t->next;	596	t = t->next;
597	};	597	};
598	log (LOG_DEBUG, "%s: No such tunnel %d to generate call.\n", __FUNCTION__,	598	_log (LOG_DEBUG, "%s: No such tunnel %d to generate call.\n", __FUNCTION__,
599	tid);	599	tid);
600	return NULL;	600	return NULL;
601	}	601	}
Lines 606-630 Link Here
606	lac = (struct lac *) data;	606	lac = (struct lac *) data;
607	if (!lac->active)	607	if (!lac->active)
608	{	608	{
609	log (LOG_DEBUG, "%s: LAC %s not active", __FUNCTION__, lac->entname);	609	_log (LOG_DEBUG, "%s: LAC %s not active", __FUNCTION__, lac->entname);
610	return;	610	return;
611	}	611	}
612	lac->rsched = NULL;	612	lac->rsched = NULL;
613	lac->rtries++;	613	lac->rtries++;
614	if (lac->rmax && (lac->rtries > lac->rmax))	614	if (lac->rmax && (lac->rtries > lac->rmax))
615	{	615	{
616	log (LOG_LOG, "%s: maximum retries exceeded.\n", __FUNCTION__);	616	_log (LOG_LOG, "%s: maximum retries exceeded.\n", __FUNCTION__);
617	return;	617	return;
618	}	618	}
619	if (!lac)	619	if (!lac)
620	{	620	{
621	log (LOG_WARN, "%s : called on NULL lac!\n", __FUNCTION__);	621	_log (LOG_WARN, "%s : called on NULL lac!\n", __FUNCTION__);
622	return;	622	return;
623	}	623	}
624	if (!lac->t)	624	if (!lac->t)
625	{	625	{
626	#ifdef DEGUG_MAGIC	626	#ifdef DEGUG_MAGIC
627	log (LOG_DEBUG, "%s : tunnel not up! Connecting!\n", __FUNCTION__);	627	_log (LOG_DEBUG, "%s : tunnel not up! Connecting!\n", __FUNCTION__);
628	#endif	628	#endif
629	magic_lac_tunnel (lac);	629	magic_lac_tunnel (lac);
630	return;	630	return;
Lines 643-649 Link Here
643	{	643	{
644	if (tmp->ourcid == cid)	644	if (tmp->ourcid == cid)
645	{	645	{
646	log (LOG_LOG,	646	_log (LOG_LOG,
647	"%s :Hanging up call %d, Local: %d, Remote: %d\n",	647	"%s :Hanging up call %d, Local: %d, Remote: %d\n",
648	__FUNCTION__, tmp->serno, tmp->ourcid, tmp->cid);	648	__FUNCTION__, tmp->serno, tmp->ourcid, tmp->cid);
649	strcpy (tmp->errormsg, "Goodbye!");	649	strcpy (tmp->errormsg, "Goodbye!");
Lines 655-661 Link Here
655	}	655	}
656	t = t->next;	656	t = t->next;
657	};	657	};
658	log (LOG_DEBUG, "%s : No such call %d to hang up.\n", __FUNCTION__, cid);	658	_log (LOG_DEBUG, "%s : No such call %d to hang up.\n", __FUNCTION__, cid);
659	return;	659	return;
660	}	660	}
661		661
Lines 666-672 Link Here
666	{	666	{
667	if (t->ourtid == tid)	667	if (t->ourtid == tid)
668	{	668	{
669	log (LOG_LOG,	669	_log (LOG_LOG,
670	"%s: Disconnecting from %s, Local: %d, Remote: %d\n",	670	"%s: Disconnecting from %s, Local: %d, Remote: %d\n",
671	__FUNCTION__, IPADDY (t->peer.sin_addr), t->ourtid, t->tid);	671	__FUNCTION__, IPADDY (t->peer.sin_addr), t->ourtid, t->tid);
672	t->self->needclose = -1;	672	t->self->needclose = -1;
Lines 676-682 Link Here
676	}	676	}
677	t = t->next;	677	t = t->next;
678	};	678	};
679	log (LOG_DEBUG, "%s: No such tunnel %d to hang up.\n", __FUNCTION__, tid);	679	_log (LOG_DEBUG, "%s: No such tunnel %d to hang up.\n", __FUNCTION__, tid);
680	return;	680	return;
681	}	681	}
682		682
Lines 709-715 Link Here
709	temp = (int *)entropy_buf;	709	temp = (int *)entropy_buf;
710	tmp->ourtid = *temp & 0xFFFF;	710	tmp->ourtid = *temp & 0xFFFF;
711	#ifdef DEBUG_ENTROPY	711	#ifdef DEBUG_ENTROPY
712	log(LOG_DEBUG, "ourtid = %u, entropy_buf = %hx\n", tmp->ourtid, *temp);	712	_log(LOG_DEBUG, "ourtid = %u, entropy_buf = %hx\n", tmp->ourtid, *temp);
713	#endif	713	#endif
714	}	714	}
715	#else	715	#else
Lines 773-779 Link Here
773	if (buf[cnt - 1] == '\n')	773	if (buf[cnt - 1] == '\n')
774	buf[--cnt] = 0;	774	buf[--cnt] = 0;
775	#ifdef DEBUG_CONTROL	775	#ifdef DEBUG_CONTROL
776	log (LOG_DEBUG, "%s: Got message %s (%d bytes long)\n",	776	_log (LOG_DEBUG, "%s: Got message %s (%d bytes long)\n",
777	__FUNCTION__, buf, cnt);	777	__FUNCTION__, buf, cnt);
778	#endif	778	#endif
779	switch (buf[0])	779	switch (buf[0])
Lines 781-787 Link Here
781	case 't':	781	case 't':
782	host = strchr (buf, ' ') + 1;	782	host = strchr (buf, ' ') + 1;
783	#ifdef DEBUG_CONTROL	783	#ifdef DEBUG_CONTROL
784	log (LOG_DEBUG, "%s: Attempting to tunnel to %s\n",	784	_log (LOG_DEBUG, "%s: Attempting to tunnel to %s\n",
785	__FUNCTION__, host);	785	__FUNCTION__, host);
786	#endif	786	#endif
787	l2tp_call (host, UDP_LISTEN_PORT, NULL, NULL);	787	l2tp_call (host, UDP_LISTEN_PORT, NULL, NULL);
Lines 801-807 Link Here
801	if (!lac->c)	801	if (!lac->c)
802	magic_lac_dial (lac);	802	magic_lac_dial (lac);
803	else	803	else
804	log (LOG_DEBUG,	804	_log (LOG_DEBUG,
805	"%s: Session '%s' already active!\n",	805	"%s: Session '%s' already active!\n",
806	__FUNCTION__, lac->entname);	806	__FUNCTION__, lac->entname);
807	break;	807	break;
Lines 813-824 Link Here
813	tunl = atoi (tunstr);	813	tunl = atoi (tunstr);
814	if (!tunl)	814	if (!tunl)
815	{	815	{
816	log (LOG_DEBUG, "%s: No such tunnel '%s'\n", __FUNCTION__,	816	_log (LOG_DEBUG, "%s: No such tunnel '%s'\n", __FUNCTION__,
817	tunstr);	817	tunstr);
818	break;	818	break;
819	}	819	}
820	#ifdef DEBUG_CONTROL	820	#ifdef DEBUG_CONTROL
821	log (LOG_DEBUG, "%s: Attempting to call on tunnel %d\n",	821	_log (LOG_DEBUG, "%s: Attempting to call on tunnel %d\n",
822	__FUNCTION__, tunl);	822	__FUNCTION__, tunl);
823	#endif	823	#endif
824	lac_call (tunl, NULL, NULL);	824	lac_call (tunl, NULL, NULL);
Lines 844-850 Link Here
844	if (!lac->c)	844	if (!lac->c)
845	magic_lac_dial (lac);	845	magic_lac_dial (lac);
846	else	846	else
847	log (LOG_DEBUG,	847	_log (LOG_DEBUG,
848	"%s: Session '%s' already active!\n",	848	"%s: Session '%s' already active!\n",
849	__FUNCTION__, lac->entname);	849	__FUNCTION__, lac->entname);
850	break;	850	break;
Lines 856-867 Link Here
856	tunl = atoi (tunstr);	856	tunl = atoi (tunstr);
857	if (!tunl)	857	if (!tunl)
858	{	858	{
859	log (LOG_DEBUG, "%s: No such tunnel '%s'\n", __FUNCTION__,	859	_log (LOG_DEBUG, "%s: No such tunnel '%s'\n", __FUNCTION__,
860	tunstr);	860	tunstr);
861	break;	861	break;
862	}	862	}
863	#ifdef DEBUG_CONTROL	863	#ifdef DEBUG_CONTROL
864	log (LOG_DEBUG, "%s: Attempting to call on tunnel %d\n",	864	_log (LOG_DEBUG, "%s: Attempting to call on tunnel %d\n",
865	__FUNCTION__, tunl);	865	__FUNCTION__, tunl);
866	#endif	866	#endif
867	lac_call (tunl, NULL, NULL);	867	lac_call (tunl, NULL, NULL);
Lines 871-877 Link Here
871	callstr = strchr (buf, ' ') + 1;	871	callstr = strchr (buf, ' ') + 1;
872	call = atoi (callstr);	872	call = atoi (callstr);
873	#ifdef DEBUG_CONTROL	873	#ifdef DEBUG_CONTROL
874	log (LOG_DEBUG, "%s: Attempting to call %d\n", __FUNCTION__,	874	_log (LOG_DEBUG, "%s: Attempting to call %d\n", __FUNCTION__,
875	call);	875	call);
876	#endif	876	#endif
877	lac_hangup (call);	877	lac_hangup (call);
Lines 888-894 Link Here
888	if (lac->t)	888	if (lac->t)
889	lac_disconnect (lac->t->ourtid);	889	lac_disconnect (lac->t->ourtid);
890	else	890	else
891	log (LOG_DEBUG, "%s: Session '%s' not up\n",	891	_log (LOG_DEBUG, "%s: Session '%s' not up\n",
892	__FUNCTION__, lac->entname);	892	__FUNCTION__, lac->entname);
893	break;	893	break;
894	}	894	}
Lines 899-910 Link Here
899	tunl = atoi (tunstr);	899	tunl = atoi (tunstr);
900	if (!tunl)	900	if (!tunl)
901	{	901	{
902	log (LOG_DEBUG, "%s: No such tunnel '%s'\n", __FUNCTION__,	902	_log (LOG_DEBUG, "%s: No such tunnel '%s'\n", __FUNCTION__,
903	tunstr);	903	tunstr);
904	break;	904	break;
905	}	905	}
906	#ifdef DEBUG_CONTROL	906	#ifdef DEBUG_CONTROL
907	log (LOG_DEBUG, "%s: Attempting to disconnect tunnel %d\n",	907	_log (LOG_DEBUG, "%s: Attempting to disconnect tunnel %d\n",
908	__FUNCTION__, tunl);	908	__FUNCTION__, tunl);
909	#endif	909	#endif
910	lac_disconnect (tunl);	910	lac_disconnect (tunl);
Lines 913-919 Link Here
913	show_status (1);	913	show_status (1);
914	break;	914	break;
915	default:	915	default:
916	log (LOG_DEBUG, "%s: Unknown command %c\n", __FUNCTION__,	916	_log (LOG_DEBUG, "%s: Unknown command %c\n", __FUNCTION__,
917	buf[0]);	917	buf[0]);
918	}	918	}
919	}	919	}
Lines 986-992 Link Here
986	int pidfilewritten=0;	986	int pidfilewritten=0;
987		987
988	if((pid = fork()) < 0) {	988	if((pid = fork()) < 0) {
989	log(LOG_LOG, "%s: Unable to fork ()\n",__FUNCTION__);	989	_log(LOG_LOG, "%s: Unable to fork ()\n",__FUNCTION__);
990	close(server_socket);	990	close(server_socket);
991	exit(1);	991	exit(1);
992	}	992	}
Lines 1003-1009 Link Here
1003	if ((i = open(gconfig.pidfile,O_RDONLY)) > 0) {	1003	if ((i = open(gconfig.pidfile,O_RDONLY)) > 0) {
1004	l=read(i,buf,sizeof(buf)-1);	1004	l=read(i,buf,sizeof(buf)-1);
1005	if (i < 0) {	1005	if (i < 0) {
1006	log(LOG_LOG, "%s: Unable to read pid file [%s]\n",	1006	_log(LOG_LOG, "%s: Unable to read pid file [%s]\n",
1007	__FUNCTION__, gconfig.pidfile);	1007	__FUNCTION__, gconfig.pidfile);
1008	}	1008	}
1009	buf[i] = '\0';	1009	buf[i] = '\0';
Lines 1023-1029 Link Here
1023	}	1023	}
1024	else	1024	else
1025	{	1025	{
1026	log(LOG_LOG, "%s: There's already a l2tpd server running.\n",	1026	_log(LOG_LOG, "%s: There's already a l2tpd server running.\n",
1027	__FUNCTION__);	1027	__FUNCTION__);
1028	close(server_socket);	1028	close(server_socket);
1029	exit(1);	1029	exit(1);
Lines 1053-1064 Link Here
1053	init_addr ();	1053	init_addr ();
1054	if (init_config ())	1054	if (init_config ())
1055	{	1055	{
1056	log (LOG_CRIT, "%s: Unable to load config file\n", __FUNCTION__);	1056	_log (LOG_CRIT, "%s: Unable to load config file\n", __FUNCTION__);
1057	exit (1);	1057	exit (1);
1058	}	1058	}
1059	if (uname (&uts))	1059	if (uname (&uts))
1060	{	1060	{
1061	log (LOG_CRIT, "%s : Unable to determine host system\n",	1061	_log (LOG_CRIT, "%s : Unable to determine host system\n",
1062	__FUNCTION__);	1062	__FUNCTION__);
1063	exit (1);	1063	exit (1);
1064	}	1064	}
Lines 1077-1093 Link Here
1077	control_fd = open (CONTROL_PIPE, O_RDONLY \| O_NONBLOCK, 0600);	1077	control_fd = open (CONTROL_PIPE, O_RDONLY \| O_NONBLOCK, 0600);
1078	if (control_fd < 0)	1078	if (control_fd < 0)
1079	{	1079	{
1080	log (LOG_CRIT, "%s: Unable to open " CONTROL_PIPE " for reading.",	1080	_log (LOG_CRIT, "%s: Unable to open " CONTROL_PIPE " for reading.",
1081	__FUNCTION__);	1081	__FUNCTION__);
1082	exit (1);	1082	exit (1);
1083	}	1083	}
1084	log (LOG_LOG, "l2tpd version " SERVER_VERSION " started on %s PID:%d\n",	1084	_log (LOG_LOG, "l2tpd version " SERVER_VERSION " started on %s PID:%d\n",
1085	hostname, getpid ());	1085	hostname, getpid ());
1086	log (LOG_LOG,	1086	_log (LOG_LOG,
1087	"Written by Mark Spencer, Copyright (C) 1998, Adtran, Inc.\n");	1087	"Written by Mark Spencer, Copyright (C) 1998, Adtran, Inc.\n");
1088	log (LOG_LOG, "Forked by Scott Balmos and David Stipp, (C) 2001\n");	1088	_log (LOG_LOG, "Forked by Scott Balmos and David Stipp, (C) 2001\n");
1089	log (LOG_LOG, "Inhereted by Jeff McAdams, (C) 2002\n");	1089	_log (LOG_LOG, "Inhereted by Jeff McAdams, (C) 2002\n");
1090	log (LOG_LOG, "%s version %s on a %s, port %d\n", uts.sysname,	1090	_log (LOG_LOG, "%s version %s on a %s, port %d\n", uts.sysname,
1091	uts.release, uts.machine, gconfig.port);	1091	uts.release, uts.machine, gconfig.port);
1092	lac = laclist;	1092	lac = laclist;
1093	while (lac)	1093	while (lac)
Lines 1095-1101 Link Here
1095	if (lac->autodial)	1095	if (lac->autodial)
1096	{	1096	{
1097	#ifdef DEBUG_MAGIC	1097	#ifdef DEBUG_MAGIC
1098	log (LOG_DEBUG, "%s: Autodialing '%s'\n", __FUNCTION__,	1098	_log (LOG_DEBUG, "%s: Autodialing '%s'\n", __FUNCTION__,
1099	lac->entname[0] ? lac->entname : "(unnamed)");	1099	lac->entname[0] ? lac->entname : "(unnamed)");
1100	#endif	1100	#endif
1101	lac->active = -1;	1101	lac->active = -1;

Lines 51-57 Link Here

(-)l2tpd-0.69/network.c (-21 / +21 lines)
51	server.sin_port = htons (gconfig.port);	51	server.sin_port = htons (gconfig.port);
52	if ((server_socket = socket (PF_INET, SOCK_DGRAM, 0)) < 0)	52	if ((server_socket = socket (PF_INET, SOCK_DGRAM, 0)) < 0)
53	{	53	{
54	log (LOG_CRIT, "%s: Unable to allocate socket. Terminating.\n",	54	_log (LOG_CRIT, "%s: Unable to allocate socket. Terminating.\n",
55	__FUNCTION__);	55	__FUNCTION__);
56	return -EINVAL;	56	return -EINVAL;
57	};	57	};
Lines 60-96 Link Here
60	if (bind (server_socket, (struct sockaddr *) &server, sizeof (server)))	60	if (bind (server_socket, (struct sockaddr *) &server, sizeof (server)))
61	{	61	{
62	close (server_socket);	62	close (server_socket);
63	log (LOG_CRIT, "%s: Unable to bind socket. Terminating.\n",	63	_log (LOG_CRIT, "%s: Unable to bind socket. Terminating.\n",
64	__FUNCTION__);	64	__FUNCTION__);
65	return -EINVAL;	65	return -EINVAL;
66	};	66	};
67	if (getsockname (server_socket, (struct sockaddr *) &server, &length))	67	if (getsockname (server_socket, (struct sockaddr *) &server, &length))
68	{	68	{
69	log (LOG_CRIT, "%s: Unable to read socket name.Terminating.\n",	69	_log (LOG_CRIT, "%s: Unable to read socket name.Terminating.\n",
70	__FUNCTION__);	70	__FUNCTION__);
71	return -EINVAL;	71	return -EINVAL;
72	}	72	}
73	#ifdef USE_KERNEL	73	#ifdef USE_KERNEL
74	if (gconfig.forceuserspace)	74	if (gconfig.forceuserspace)
75	{	75	{
76	log (LOG_LOG, "Not looking for kernel support.\n");	76	_log (LOG_LOG, "Not looking for kernel support.\n");
77	kernel_support = 0;	77	kernel_support = 0;
78	}	78	}
79	else	79	else
80	{	80	{
81	if (ioctl (server_socket, SIOCSETL2TP, NULL) < 0)	81	if (ioctl (server_socket, SIOCSETL2TP, NULL) < 0)
82	{	82	{
83	log (LOG_LOG, "L2TP kernel support not detected.\n");	83	_log (LOG_LOG, "L2TP kernel support not detected.\n");
84	kernel_support = 0;	84	kernel_support = 0;
85	}	85	}
86	else	86	else
87	{	87	{
88	log (LOG_LOG, "Using l2tp kernel support.\n");	88	_log (LOG_LOG, "Using l2tp kernel support.\n");
89	kernel_support = -1;	89	kernel_support = -1;
90	}	90	}
91	}	91	}
92	#else	92	#else
93	log (LOG_LOG, "This binary does not support kernel L2TP.\n");	93	_log (LOG_LOG, "This binary does not support kernel L2TP.\n");
94	#endif	94	#endif
95	arg = fcntl (server_socket, F_GETFL);	95	arg = fcntl (server_socket, F_GETFL);
96	arg \|= O_NONBLOCK;	96	arg \|= O_NONBLOCK;
Lines 169-175 Link Here
169	int ns;	169	int ns;
170	if (!buf)	170	if (!buf)
171	{	171	{
172	log (LOG_WARN, "%s: called on NULL buffer!\n", __FUNCTION__);	172	_log (LOG_WARN, "%s: called on NULL buffer!\n", __FUNCTION__);
173	return;	173	return;
174	}	174	}
175		175
Lines 181-187 Link Here
181	if (ns < t->cLr)	181	if (ns < t->cLr)
182	{	182	{
183	#ifdef DEBUG_CONTROL_XMIT	183	#ifdef DEBUG_CONTROL_XMIT
184	log (LOG_DEBUG, "%s: Tossing packet %d\n", __FUNCTION__, ns);	184	_log (LOG_DEBUG, "%s: Tossing packet %d\n", __FUNCTION__, ns);
185	#endif	185	#endif
186	/* Okay, it's been received. Let's toss it now */	186	/* Okay, it's been received. Let's toss it now */
187	toss (buf);	187	toss (buf);
Lines 198-204 Link Here
198	{	198	{
199	if (t->self->needclose)	199	if (t->self->needclose)
200	{	200	{
201	log (LOG_DEBUG,	201	_log (LOG_DEBUG,
202	"%s: Unable to deliver closing message for tunnel %d. Destroying anyway.\n",	202	"%s: Unable to deliver closing message for tunnel %d. Destroying anyway.\n",
203	__FUNCTION__, t->ourtid);	203	__FUNCTION__, t->ourtid);
204	t->self->needclose = 0;	204	t->self->needclose = 0;
Lines 206-212 Link Here
206	}	206	}
207	else	207	else
208	{	208	{
209	log (LOG_DEBUG,	209	_log (LOG_DEBUG,
210	"%s: Maximum retries exceeded for tunnel %d. Closing.\n",	210	"%s: Maximum retries exceeded for tunnel %d. Closing.\n",
211	__FUNCTION__, t->ourtid);	211	__FUNCTION__, t->ourtid);
212	strcpy (t->self->errormsg, "Timeout");	212	strcpy (t->self->errormsg, "Timeout");
Lines 223-229 Link Here
223	tv.tv_usec = 0;	223	tv.tv_usec = 0;
224	schedule (tv, control_xmit, buf);	224	schedule (tv, control_xmit, buf);
225	#ifdef DEBUG_CONTROL_XMIT	225	#ifdef DEBUG_CONTROL_XMIT
226	log (LOG_DEBUG, "%s: Scheduling and transmitting packet %d\n",	226	_log (LOG_DEBUG, "%s: Scheduling and transmitting packet %d\n",
227	__FUNCTION__, ns);	227	__FUNCTION__, ns);
228	#endif	228	#endif
229	udp_xmit (buf);	229	udp_xmit (buf);
Lines 279-285 Link Here
279	if (st->self->needclose ^ st->self->closing)	279	if (st->self->needclose ^ st->self->closing)
280	{	280	{
281	if (debug_tunnel)	281	if (debug_tunnel)
282	log (LOG_DEBUG, "%S: closing down tunnel %d\n",	282	_log (LOG_DEBUG, "%S: closing down tunnel %d\n",
283	__FUNCTION__, st->ourtid);	283	__FUNCTION__, st->ourtid);
284	call_close (st->self);	284	call_close (st->self);
285	/* Reset the while loop	285	/* Reset the while loop
Lines 347-359 Link Here
347	if (recvsize < 0)	347	if (recvsize < 0)
348	{	348	{
349	if (errno != EAGAIN)	349	if (errno != EAGAIN)
350	log (LOG_WARN,	350	_log (LOG_WARN,
351	"%s: recvfrom returned error %d (%s)\n",	351	"%s: recvfrom returned error %d (%s)\n",
352	__FUNCTION__, errno, strerror (errno));	352	__FUNCTION__, errno, strerror (errno));
353	}	353	}
354	else	354	else
355	{	355	{
356	log (LOG_WARN, "%s: received too small a packet\n",	356	_log (LOG_WARN, "%s: received too small a packet\n",
357	__FUNCTION__);	357	__FUNCTION__);
358	}	358	}
359	}	359	}
Lines 364-370 Link Here
364	extract (buf->start, &tunnel, &call);	364	extract (buf->start, &tunnel, &call);
365	if (debug_network)	365	if (debug_network)
366	{	366	{
367	log (LOG_DEBUG, "%s: recv packet from %s, size = %d,	367	_log (LOG_DEBUG, "%s: recv packet from %s, size = %d,\n\
368	tunnel = %d, call = %d\n", __FUNCTION__, inet_ntoa (from.sin_addr), recvsize, tunnel, call);	368	tunnel = %d, call = %d\n", __FUNCTION__, inet_ntoa (from.sin_addr), recvsize, tunnel, call);
369	}	369	}
370	if (packet_dump)	370	if (packet_dump)
Lines 389-401 Link Here
389	* to ack receiving the packet.	389	* to ack receiving the packet.
390	*/	390	*/
391	if (debug_tunnel)	391	if (debug_tunnel)
392	log (LOG_DEBUG,	392	_log (LOG_DEBUG,
393	"%s: no such call %d on tunnel %d. Sending special ZLB\n",	393	"%s: no such call %d on tunnel %d. Sending special ZLB\n",
394	__FUNCTION__);	394	__FUNCTION__);
395	handle_special (buf, c, call);	395	handle_special (buf, c, call);
396	}	396	}
397	else	397	else
398	log (LOG_DEBUG,	398	_log (LOG_DEBUG,
399	"%s: unable to find call or tunnel to handle packet. call = %d, tunnel = %d Dumping.\n",	399	"%s: unable to find call or tunnel to handle packet. call = %d, tunnel = %d Dumping.\n",
400	__FUNCTION__, call, tunnel);	400	__FUNCTION__, call, tunnel);
401		401
Lines 408-414 Link Here
408	if (handle_packet (buf, c->container, c))	408	if (handle_packet (buf, c->container, c))
409	{	409	{
410	if (debug_tunnel)	410	if (debug_tunnel)
411	log (LOG_DEBUG, "%s: bad packet\n", __FUNCTION__);	411	_log (LOG_DEBUG, "%s: bad packet\n", __FUNCTION__);
412	};	412	};
413	if (c->cnu)	413	if (c->cnu)
414	{	414	{
Lines 432-438 Link Here
432	int result;	432	int result;
433	recycle_payload (buf, sc->container->peer);	433	recycle_payload (buf, sc->container->peer);
434	#ifdef DEBUG_FLOW_MORE	434	#ifdef DEBUG_FLOW_MORE
435	log (LOG_DEBUG, "%s: rws = %d, pSs = %d, pLr = %d\n",	435	_log (LOG_DEBUG, "%s: rws = %d, pSs = %d, pLr = %d\n",
436	__FUNCTION__, sc->rws, sc->pSs, sc->pLr);	436	__FUNCTION__, sc->rws, sc->pSs, sc->pLr);
437	#endif	437	#endif
438	/* if ((sc->rws>0) && (sc->pSs > sc->pLr + sc->rws) && !sc->rbit) {	438	/* if ((sc->rws>0) && (sc->pSs > sc->pLr + sc->rws) && !sc->rbit) {
Lines 473-479 Link Here
473	}	473	}
474	if (result != 0)	474	if (result != 0)
475	{	475	{
476	log (LOG_WARN,	476	_log (LOG_WARN,
477	"%s: tossing read packet, error = %s (%d). Closing call.\n",	477	"%s: tossing read packet, error = %s (%d). Closing call.\n",
478	__FUNCTION__, strerror (-result), -result);	478	__FUNCTION__, strerror (-result), -result);
479	strcpy (sc->errormsg, strerror (-result));	479	strcpy (sc->errormsg, strerror (-result));