text:
/* ssl/ssl_ciph.c */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 *
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word 'cryptographic' can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
 * 4. If you include any Windows specific code (or a derivative thereof) from
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 *
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */
/* ====================================================================
 * Copyright (c) 1998-2006 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    openssl-core@openssl.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */
/* ====================================================================
 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
 * ECC cipher suite support in OpenSSL originally developed by
 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
 */
#include <stdio.h>
#include <openssl/objects.h>
#ifndef OPENSSL_NO_COMP
# include <openssl/comp.h>
#endif

#include "ssl_locl.h"

#define SSL_ENC_DES_IDX         0
#define SSL_ENC_3DES_IDX        1
#define SSL_ENC_RC4_IDX         2
#define SSL_ENC_RC2_IDX         3
#define SSL_ENC_IDEA_IDX        4
#define SSL_ENC_eFZA_IDX        5
#define SSL_ENC_NULL_IDX        6
#define SSL_ENC_AES128_IDX      7
#define SSL_ENC_AES256_IDX      8
#define SSL_ENC_CAMELLIA128_IDX 9
#define SSL_ENC_CAMELLIA256_IDX 10
#define SSL_ENC_SEED_IDX        11
#define SSL_ENC_NUM_IDX         12

static const EVP_CIPHER *ssl_cipher_methods[SSL_ENC_NUM_IDX] = {
    NULL, NULL, NULL, NULL, NULL, NULL,
};

#define SSL_COMP_NULL_IDX       0
#define SSL_COMP_ZLIB_IDX       1
#define SSL_COMP_NUM_IDX        2

static STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;

#define SSL_MD_MD5_IDX  0
#define SSL_MD_SHA1_IDX 1
#define SSL_MD_NUM_IDX  2
static const EVP_MD *ssl_digest_methods[SSL_MD_NUM_IDX] = {
    NULL, NULL,
};

#define CIPHER_ADD      1
#define CIPHER_KILL     2
#define CIPHER_DEL      3
#define CIPHER_ORD      4
#define CIPHER_SPECIAL  5

typedef struct cipher_order_st {
    SSL_CIPHER *cipher;
    int active;
    int dead;
    struct cipher_order_st *next, *prev;
} CIPHER_ORDER;

static const SSL_CIPHER cipher_aliases[] = {
    /* Don't include eNULL unless specifically enabled. */
    /*
     * Don't include ECC in ALL because these ciphers are not yet official.
     */
    /* must be first */
    {0, SSL_TXT_ALL, 0, SSL_ALL & ~SSL_eNULL & ~SSL_kECDH & ~SSL_kECDHE,
     SSL_ALL, 0, 0, 0, SSL_ALL, SSL_ALL},
    /*
     * TODO: COMPLEMENT OF ALL do not have ECC cipher suites handled properly.
     */
    /* COMPLEMENT OF ALL */
    {0, SSL_TXT_CMPALL, 0, SSL_eNULL, 0, 0, 0, 0, SSL_ENC_MASK, 0},
    {0, SSL_TXT_CMPDEF, 0, SSL_ADH, SSL_EXP_MASK, 0, 0, 0, SSL_AUTH_MASK, 0},
    /* VRS Kerberos5 */
    {0, SSL_TXT_kKRB5, 0, SSL_kKRB5, 0, 0, 0, 0, SSL_MKEY_MASK, 0},
    {0, SSL_TXT_kRSA, 0, SSL_kRSA, 0, 0, 0, 0, SSL_MKEY_MASK, 0},
    {0, SSL_TXT_kDHr, 0, SSL_kDHr, 0, 0, 0, 0, SSL_MKEY_MASK, 0},
    {0, SSL_TXT_kDHd, 0, SSL_kDHd, 0, 0, 0, 0, SSL_MKEY_MASK, 0},
    {0, SSL_TXT_kEDH, 0, SSL_kEDH, 0, 0, 0, 0, SSL_MKEY_MASK, 0},
    {0, SSL_TXT_kFZA, 0, SSL_kFZA, 0, 0, 0, 0, SSL_MKEY_MASK, 0},
    {0, SSL_TXT_DH, 0, SSL_DH, 0, 0, 0, 0, SSL_MKEY_MASK, 0},
    {0, SSL_TXT_ECC, 0, (SSL_kECDH | SSL_kECDHE), 0, 0, 0, 0, SSL_MKEY_MASK,
     0},
    {0, SSL_TXT_EDH, 0, SSL_EDH, 0, 0, 0, 0, SSL_MKEY_MASK | SSL_AUTH_MASK,
     0},
    /* VRS Kerberos5 */
    {0, SSL_TXT_aKRB5, 0, SSL_aKRB5, 0, 0, 0, 0, SSL_AUTH_MASK, 0},
    {0, SSL_TXT_aRSA, 0, SSL_aRSA, 0, 0, 0, 0, SSL_AUTH_MASK, 0},
    {0, SSL_TXT_aDSS, 0, SSL_aDSS, 0, 0, 0, 0, SSL_AUTH_MASK, 0},
    {0, SSL_TXT_aFZA, 0, SSL_aFZA, 0, 0, 0, 0, SSL_AUTH_MASK, 0},
    {0, SSL_TXT_aNULL, 0, SSL_aNULL, 0, 0, 0, 0, SSL_AUTH_MASK, 0},
    {0, SSL_TXT_aDH, 0, SSL_aDH, 0, 0, 0, 0, SSL_AUTH_MASK, 0},
    {0, SSL_TXT_DSS, 0, SSL_DSS, 0, 0, 0, 0, SSL_AUTH_MASK, 0},

    {0, SSL_TXT_DES, 0, SSL_DES, 0, 0, 0, 0, SSL_ENC_MASK, 0},
    {0, SSL_TXT_3DES, 0, SSL_3DES, 0, 0, 0, 0, SSL_ENC_MASK, 0},
    {0, SSL_TXT_RC4, 0, SSL_RC4, 0, 0, 0, 0, SSL_ENC_MASK, 0},
    {0, SSL_TXT_RC2, 0, SSL_RC2, 0, 0, 0, 0, SSL_ENC_MASK, 0},
#ifndef OPENSSL_NO_IDEA
    {0, SSL_TXT_IDEA, 0, SSL_IDEA, 0, 0, 0, 0, SSL_ENC_MASK, 0},
#endif
    {0, SSL_TXT_SEED, 0, SSL_SEED, 0, 0, 0, 0, SSL_ENC_MASK, 0},
    {0, SSL_TXT_eNULL, 0, SSL_eNULL, 0, 0, 0, 0, SSL_ENC_MASK, 0},
    {0, SSL_TXT_eFZA, 0, SSL_eFZA, 0, 0, 0, 0, SSL_ENC_MASK, 0},
    {0, SSL_TXT_AES, 0, SSL_AES, 0, 0, 0, 0, SSL_ENC_MASK, 0},
    {0, SSL_TXT_CAMELLIA, 0, SSL_CAMELLIA, 0, 0, 0, 0, SSL_ENC_MASK, 0},

    {0, SSL_TXT_MD5, 0, SSL_MD5, 0, 0, 0, 0, SSL_MAC_MASK, 0},
    {0, SSL_TXT_SHA1, 0, SSL_SHA1, 0, 0, 0, 0, SSL_MAC_MASK, 0},
    {0, SSL_TXT_SHA, 0, SSL_SHA, 0, 0, 0, 0, SSL_MAC_MASK, 0},

    {0, SSL_TXT_NULL, 0, SSL_NULL, 0, 0, 0, 0, SSL_ENC_MASK, 0},
    {0, SSL_TXT_KRB5, 0, SSL_KRB5, 0, 0, 0, 0, SSL_AUTH_MASK | SSL_MKEY_MASK,
     0},
    {0, SSL_TXT_RSA, 0, SSL_RSA, 0, 0, 0, 0, SSL_AUTH_MASK | SSL_MKEY_MASK,
     0},
    {0, SSL_TXT_ADH, 0, SSL_ADH, 0, 0, 0, 0, SSL_AUTH_MASK | SSL_MKEY_MASK,
     0},
    {0, SSL_TXT_FZA, 0, SSL_FZA, 0, 0, 0, 0,
     SSL_AUTH_MASK | SSL_MKEY_MASK | SSL_ENC_MASK, 0},

    {0, SSL_TXT_SSLV2, 0, SSL_SSLV2, 0, 0, 0, 0, SSL_SSL_MASK, 0},
    {0, SSL_TXT_SSLV3, 0, SSL_SSLV3, 0, 0, 0, 0, SSL_SSL_MASK, 0},
    {0, SSL_TXT_TLSV1, 0, SSL_TLSV1, 0, 0, 0, 0, SSL_SSL_MASK, 0},

    {0, SSL_TXT_EXP, 0, 0, SSL_EXPORT, 0, 0, 0, 0, SSL_EXP_MASK},
    {0, SSL_TXT_EXPORT, 0, 0, SSL_EXPORT, 0, 0, 0, 0, SSL_EXP_MASK},
    {0, SSL_TXT_EXP40, 0, 0, SSL_EXP40, 0, 0, 0, 0, SSL_STRONG_MASK},
    {0, SSL_TXT_EXP56, 0, 0, SSL_EXP56, 0, 0, 0, 0, SSL_STRONG_MASK},
    {0, SSL_TXT_LOW, 0, 0, SSL_LOW, 0, 0, 0, 0, SSL_STRONG_MASK},
    {0, SSL_TXT_MEDIUM, 0, 0, SSL_MEDIUM, 0, 0, 0, 0, SSL_STRONG_MASK},
    {0, SSL_TXT_HIGH, 0, 0, SSL_HIGH, 0, 0, 0, 0, SSL_STRONG_MASK},
    {0, SSL_TXT_FIPS, 0, 0, SSL_FIPS, 0, 0, 0, 0, SSL_FIPS | SSL_STRONG_NONE},
};

void ssl_load_ciphers(void)
{
    ssl_cipher_methods[SSL_ENC_DES_IDX] = EVP_get_cipherbyname(SN_des_cbc);
    ssl_cipher_methods[SSL_ENC_3DES_IDX] =
        EVP_get_cipherbyname(SN_des_ede3_cbc);
    ssl_cipher_methods[SSL_ENC_RC4_IDX] = EVP_get_cipherbyname(SN_rc4);
    ssl_cipher_methods[SSL_ENC_RC2_IDX] = EVP_get_cipherbyname(SN_rc2_cbc);
#ifndef OPENSSL_NO_IDEA
    ssl_cipher_methods[SSL_ENC_IDEA_IDX] = EVP_get_cipherbyname(SN_idea_cbc);
#else
    ssl_cipher_methods[SSL_ENC_IDEA_IDX] = NULL;
#endif
    ssl_cipher_methods[SSL_ENC_AES128_IDX] =
        EVP_get_cipherbyname(SN_aes_128_cbc);
    ssl_cipher_methods[SSL_ENC_AES256_IDX] =
        EVP_get_cipherbyname(SN_aes_256_cbc);
    ssl_cipher_methods[SSL_ENC_CAMELLIA128_IDX] =
        EVP_get_cipherbyname(SN_camellia_128_cbc);
    ssl_cipher_methods[SSL_ENC_CAMELLIA256_IDX] =
        EVP_get_cipherbyname(SN_camellia_256_cbc);
    ssl_cipher_methods[SSL_ENC_SEED_IDX] = EVP_get_cipherbyname(SN_seed_cbc);

    ssl_digest_methods[SSL_MD_MD5_IDX] = EVP_get_digestbyname(SN_md5);
    ssl_digest_methods[SSL_MD_SHA1_IDX] = EVP_get_digestbyname(SN_sha1);
}

#ifndef OPENSSL_NO_COMP

static int sk_comp_cmp(const SSL_COMP *const *a, const SSL_COMP *const *b)
{
    return ((*a)->id - (*b)->id);
}

static void load_builtin_compressions(void)
{
    int got_write_lock = 0;

    CRYPTO_r_lock(CRYPTO_LOCK_SSL);
    if (ssl_comp_methods == NULL) {
        CRYPTO_r_unlock(CRYPTO_LOCK_SSL);
        CRYPTO_w_lock(CRYPTO_LOCK_SSL);
        got_write_lock = 1;

        if (ssl_comp_methods == NULL) {
            SSL_COMP *comp = NULL;

            MemCheck_off();
            ssl_comp_methods = sk_SSL_COMP_new(sk_comp_cmp);
            if (ssl_comp_methods != NULL) {
                comp = (SSL_COMP *)OPENSSL_malloc(sizeof(SSL_COMP));
                if (comp != NULL) {
                    comp->method = COMP_zlib();
                    if (comp->method && comp->method->type == NID_undef)
                        OPENSSL_free(comp);
                    else {
                        comp->id = SSL_COMP_ZLIB_IDX;
                        comp->name = comp->method->name;
                        sk_SSL_COMP_push(ssl_comp_methods, comp);
                    }
                }
                sk_SSL_COMP_sort(ssl_comp_methods);
            }
            MemCheck_on();
        }
    }

    if (got_write_lock)
        CRYPTO_w_unlock(CRYPTO_LOCK_SSL);
    else
        CRYPTO_r_unlock(CRYPTO_LOCK_SSL);
}
#endif

int ssl_cipher_get_evp(const SSL_SESSION *s, const EVP_CIPHER **enc,
                       const EVP_MD **md, SSL_COMP **comp)
{
    int i;
    SSL_CIPHER *c;

    c = s->cipher;
    if (c == NULL)
        return (0);
    if (comp != NULL) {
        SSL_COMP ctmp;
#ifndef OPENSSL_NO_COMP
        load_builtin_compressions();
#endif

        *comp = NULL;
        ctmp.id = s->compress_meth;
        if (ssl_comp_methods != NULL) {
            i = sk_SSL_COMP_find(ssl_comp_methods, &ctmp);
            if (i >= 0)
                *comp = sk_SSL_COMP_value(ssl_comp_methods, i);
            else
                *comp = NULL;
        }
    }

    if ((enc == NULL) || (md == NULL))
        return (0);

    switch (c->algorithms & SSL_ENC_MASK) {
    case SSL_DES:
        i = SSL_ENC_DES_IDX;
        break;
    case SSL_3DES:
        i = SSL_ENC_3DES_IDX;
        break;
    case SSL_RC4:
        i = SSL_ENC_RC4_IDX;
        break;
    case SSL_RC2:
        i = SSL_ENC_RC2_IDX;
        break;
    case SSL_IDEA:
        i = SSL_ENC_IDEA_IDX;
        break;
    case SSL_eNULL:
        i = SSL_ENC_NULL_IDX;
        break;
    case SSL_AES:
        switch (c->alg_bits) {
        case 128:
            i = SSL_ENC_AES128_IDX;
            break;
        case 256:
            i = SSL_ENC_AES256_IDX;
            break;
        default:
            i = -1;
            break;
        }
        break;
    case SSL_CAMELLIA:
        switch (c->alg_bits) {
        case 128:
            i = SSL_ENC_CAMELLIA128_IDX;
            break;
        case 256:
            i = SSL_ENC_CAMELLIA256_IDX;
            break;
        default:
            i = -1;
            break;
        }
        break;
    case SSL_SEED:
        i = SSL_ENC_SEED_IDX;
        break;

    default:
        i = -1;
        break;
    }

    if ((i < 0) || (i >= SSL_ENC_NUM_IDX))
        *enc = NULL;
    else {
        if (i == SSL_ENC_NULL_IDX)
            *enc = EVP_enc_null();
        else
            *enc = ssl_cipher_methods[i];
    }

    switch (c->algorithms & SSL_MAC_MASK) {
    case SSL_MD5:
        i = SSL_MD_MD5_IDX;
        break;
    case SSL_SHA1:
        i = SSL_MD_SHA1_IDX;
        break;
    default:
        i = -1;
        break;
    }
    if ((i < 0) || (i >= SSL_MD_NUM_IDX))
        *md = NULL;
    else
        *md = ssl_digest_methods[i];

    if ((*enc != NULL) && (*md != NULL))
        return (1);
    else
        return (0);
}

#define ITEM_SEP(a) \
        (((a) == ':') || ((a) == ' ') || ((a) == ';') || ((a) == ','))

static void ll_append_tail(CIPHER_ORDER **head, CIPHER_ORDER *curr,
                           CIPHER_ORDER **tail)
{
    if (curr == *tail)
        return;
    if (curr == *head)
        *head = curr->next;
    if (curr->prev != NULL)
        curr->prev->next = curr->next;
    if (curr->next != NULL)     /* should always be true */
        curr->next->prev = curr->prev;
    (*tail)->next = curr;
    curr->prev = *tail;
    curr->next = NULL;
    *tail = curr;
}

struct disabled_masks {         /* This is a kludge no longer needed with
                                 * OpenSSL 0.9.9, where 128-bit and 256-bit
                                 * algorithms simply will get separate bits. */
    unsigned long mask;         /* everything except m256 */
    unsigned long m256;         /* applies to 256-bit algorithms only */
};

static struct disabled_masks ssl_cipher_get_disabled(void)
{
    unsigned long mask;
    unsigned long m256;
    struct disabled_masks ret;

    mask = SSL_kFZA;
#ifdef OPENSSL_NO_RSA
    mask |= SSL_aRSA | SSL_kRSA;
#endif
#ifdef OPENSSL_NO_DSA
    mask |= SSL_aDSS;
#endif
#ifdef OPENSSL_NO_DH
    mask |= SSL_kDHr | SSL_kDHd | SSL_kEDH | SSL_aDH;
#endif
#ifdef OPENSSL_NO_KRB5
    mask |= SSL_kKRB5 | SSL_aKRB5;
#endif
#ifdef OPENSSL_NO_ECDH
    mask |= SSL_kECDH | SSL_kECDHE;
#endif
#ifdef SSL_FORBID_ENULL
    mask |= SSL_eNULL;
#endif

    mask |= (ssl_cipher_methods[SSL_ENC_DES_IDX] == NULL) ? SSL_DES : 0;
    mask |= (ssl_cipher_methods[SSL_ENC_3DES_IDX] == NULL) ? SSL_3DES : 0;
    mask |= (ssl_cipher_methods[SSL_ENC_RC4_IDX] == NULL) ? SSL_RC4 : 0;
    mask |= (ssl_cipher_methods[SSL_ENC_RC2_IDX] == NULL) ? SSL_RC2 : 0;
    mask |= (ssl_cipher_methods[SSL_ENC_IDEA_IDX] == NULL) ? SSL_IDEA : 0;
    mask |= (ssl_cipher_methods[SSL_ENC_eFZA_IDX] == NULL) ? SSL_eFZA : 0;
    mask |= (ssl_cipher_methods[SSL_ENC_SEED_IDX] == NULL) ? SSL_SEED : 0;

    mask |= (ssl_digest_methods[SSL_MD_MD5_IDX] == NULL) ? SSL_MD5 : 0;
    mask |= (ssl_digest_methods[SSL_MD_SHA1_IDX] == NULL) ? SSL_SHA1 : 0;

    /* finally consider algorithms where mask and m256 differ */
    m256 = mask;
    mask |= (ssl_cipher_methods[SSL_ENC_AES128_IDX] == NULL) ? SSL_AES : 0;
    mask |=
        (ssl_cipher_methods[SSL_ENC_CAMELLIA128_IDX] ==
         NULL) ? SSL_CAMELLIA : 0;
    m256 |= (ssl_cipher_methods[SSL_ENC_AES256_IDX] == NULL) ? SSL_AES : 0;
    m256 |=
        (ssl_cipher_methods[SSL_ENC_CAMELLIA256_IDX] ==
         NULL) ? SSL_CAMELLIA : 0;

    ret.mask = mask;
    ret.m256 = m256;
    return ret;
}

static void ssl_cipher_collect_ciphers(const SSL_METHOD *ssl_method,
                                       int num_of_ciphers, unsigned long mask,
                                       unsigned long m256,
                                       CIPHER_ORDER *co_list,
                                       CIPHER_ORDER **head_p,
                                       CIPHER_ORDER **tail_p)
{
    int i, co_list_num;
    SSL_CIPHER *c;

    /*
     * We have num_of_ciphers descriptions compiled in, depending on the
     * method selected (SSLv2 and/or SSLv3, TLSv1 etc).
     * These will later be sorted in a linked list with at most num
     * entries.
     */

    /* Get the initial list of ciphers */
    co_list_num = 0;            /* actual count of ciphers */
    for (i = 0; i < num_of_ciphers; i++) {
        c = ssl_method->get_cipher(i);
#define IS_MASKED(c) ((c)->algorithms & (((c)->alg_bits == 256) ? m256 : mask))
        /* drop those that use any of that is not available */
#ifdef OPENSSL_FIPS
        if ((c != NULL) && c->valid && !IS_MASKED(c)
            && (!FIPS_mode() || (c->algo_strength & SSL_FIPS)))
#else
        if ((c != NULL) && c->valid && !IS_MASKED(c))
#endif
        {
            co_list[co_list_num].cipher = c;
            co_list[co_list_num].next = NULL;
            co_list[co_list_num].prev = NULL;
            co_list[co_list_num].active = 0;
            co_list_num++;
#ifdef KSSL_DEBUG
            printf("\t%d: %s %lx %lx\n", i, c->name, c->id, c->algorithms);
#endif                          /* KSSL_DEBUG */
            /*
             * if (!sk_push(ca_list,(char *)c)) goto err;
             */
        }
    }

    /*
     * Prepare linked list from list entries
     */
    for (i = 1; i < co_list_num - 1; i++) {
        co_list[i].prev = &(co_list[i - 1]);
        co_list[i].next = &(co_list[i + 1]);
    }
    if (co_list_num > 0) {
        (*head_p) = &(co_list[0]);
        (*head_p)->prev = NULL;
        (*head_p)->next = &(co_list[1]);
        (*tail_p) = &(co_list[co_list_num - 1]);
        (*tail_p)->prev = &(co_list[co_list_num - 2]);
        (*tail_p)->next = NULL;
    }
}

static void ssl_cipher_collect_aliases(SSL_CIPHER **ca_list,
                                       int num_of_group_aliases,
                                       unsigned long mask, CIPHER_ORDER *head)
{
    CIPHER_ORDER *ciph_curr;
    SSL_CIPHER **ca_curr;
    int i;

    /*
     * First, add the real ciphers as already collected
     */
    ciph_curr = head;
    ca_curr = ca_list;
    while (ciph_curr != NULL) {
        *ca_curr = ciph_curr->cipher;
        ca_curr++;
        ciph_curr = ciph_curr->next;
    }

    /*
     * Now we add the available ones from the cipher_aliases[] table.
     * They represent either an algorithm, that must be fully
     * supported (not match any bit in mask) or represent a cipher
     * strength value (will be added in any case because algorithms=0).
     */
    for (i = 0; i < num_of_group_aliases; i++) {
        if ((i == 0) ||         /* always fetch "ALL" */
            !(cipher_aliases[i].algorithms & mask)) {
            *ca_curr = (SSL_CIPHER *)(cipher_aliases + i);
            ca_curr++;
        }
    }

    *ca_curr = NULL;            /* end of list */
}

static void ssl_cipher_apply_rule(unsigned long cipher_id,
                                  unsigned long ssl_version,
                                  unsigned long algorithms,
                                  unsigned long mask,
                                  unsigned long algo_strength,
                                  unsigned long mask_strength, int rule,
                                  int strength_bits, CIPHER_ORDER *co_list,
                                  CIPHER_ORDER **head_p,
                                  CIPHER_ORDER **tail_p)
{
    CIPHER_ORDER *head, *tail, *curr, *curr2, *tail2;
    SSL_CIPHER *cp;
    unsigned long ma, ma_s;

#ifdef CIPHER_DEBUG
    printf("Applying rule %d with %08lx %08lx %08lx %08lx (%d)\n",
           rule, algorithms, mask, algo_strength, mask_strength,
           strength_bits);
#endif

    curr = head = *head_p;
    curr2 = head;
    tail2 = tail = *tail_p;
    for (;;) {
        if ((curr == NULL) || (curr == tail2))
            break;
        curr = curr2;
        curr2 = curr->next;

        cp = curr->cipher;
        /* Special case: only satisfied by COMPLEMENTOFDEFAULT */
        if (algo_strength == SSL_EXP_MASK) {
            if ((SSL_C_IS_EXPORT(cp) || cp->algorithms & SSL_SSLV2
                || cp->algorithms & SSL_aNULL)
                && !(cp->algorithms & (SSL_kECDHE|SSL_kECDH)))
                goto ok;
            else
                continue;
        }

        /*
         * If explicit cipher suite, match only that one for its own protocol
         * version. Usual selection criteria will be used for similar
         * ciphersuites from other version!
         */

        if (cipher_id && (cp->algorithms & SSL_SSL_MASK) == ssl_version) {
            if (cp->id != cipher_id)
                continue;
        }

        /*
         * Selection criteria is either the number of strength_bits
         * or the algorithm used.
         */
        else if (strength_bits == -1) {
            ma = mask & cp->algorithms;
            ma_s = mask_strength & cp->algo_strength;

#ifdef CIPHER_DEBUG
            printf
                ("\nName: %s:\nAlgo = %08lx Algo_strength = %08lx\nMask = %08lx Mask_strength %08lx\n",
                 cp->name, cp->algorithms, cp->algo_strength, mask,
                 mask_strength);
            printf("ma = %08lx ma_s %08lx, ma&algo=%08lx, ma_s&algos=%08lx\n",
                   ma, ma_s, ma & algorithms, ma_s & algo_strength);
#endif
            /*
             * Select: if none of the mask bit was met from the
             * cipher or not all of the bits were met, the
             * selection does not apply.
             */
            if (((ma == 0) && (ma_s == 0)) ||
                ((ma & algorithms) != ma) || ((ma_s & algo_strength) != ma_s))
                continue;       /* does not apply */
        } else if (strength_bits != cp->strength_bits)
            continue;           /* does not apply */

        ok:

#ifdef CIPHER_DEBUG
        printf("Action = %d\n", rule);
#endif

        /* add the cipher if it has not been added yet. */
        if (rule == CIPHER_ADD) {
            if (!curr->active) {
                int add_this_cipher = 1;

                if (((cp->algorithms & (SSL_kECDHE | SSL_kECDH | SSL_aECDSA))
                     != 0)) {
                    /*
                     * Make sure "ECCdraft" ciphersuites are activated only
                     * if *explicitly* requested, but not implicitly (such as
                     * as part of the "AES" alias).
                     */

                    add_this_cipher =
                        (mask & (SSL_kECDHE | SSL_kECDH | SSL_aECDSA)) != 0
                        || cipher_id != 0;
                }

                if (add_this_cipher) {
                    ll_append_tail(&head, curr, &tail);
                    curr->active = 1;
                }
            }
        }
        /* Move the added cipher to this location */
        else if (rule == CIPHER_ORD) {
            if (curr->active) {
                ll_append_tail(&head, curr, &tail);
            }
        } else if (rule == CIPHER_DEL)
            curr->active = 0;
        else if (rule == CIPHER_KILL) {
            if (head == curr)
                head = curr->next;
            else
                curr->prev->next = curr->next;
            if (tail == curr)
                tail = curr->prev;
            curr->active = 0;
            if (curr->next != NULL)
                curr->next->prev = curr->prev;
            if (curr->prev != NULL)
                curr->prev->next = curr->next;
            curr->next = NULL;
            curr->prev = NULL;
        }
    }

    *head_p = head;
    *tail_p = tail;
}

static int ssl_cipher_strength_sort(CIPHER_ORDER *co_list,
                                    CIPHER_ORDER **head_p,
                                    CIPHER_ORDER **tail_p)
{
    int max_strength_bits, i, *number_uses;
    CIPHER_ORDER *curr;

    /*
     * This routine sorts the ciphers with descending strength. The sorting
     * must keep the pre-sorted sequence, so we apply the normal sorting
     * routine as '+' movement to the end of the list.
     */
    max_strength_bits = 0;
    curr = *head_p;
    while (curr != NULL) {
        if (curr->active && (curr->cipher->strength_bits > max_strength_bits))
            max_strength_bits = curr->cipher->strength_bits;
        curr = curr->next;
    }

    number_uses = OPENSSL_malloc((max_strength_bits + 1) * sizeof(int));
    if (!number_uses) {
        SSLerr(SSL_F_SSL_CIPHER_STRENGTH_SORT, ERR_R_MALLOC_FAILURE);
        return (0);
    }
    memset(number_uses, 0, (max_strength_bits + 1) * sizeof(int));

    /*
     * Now find the strength_bits values actually used
     */
    curr = *head_p;
    while (curr != NULL) {
        if (curr->active)
            number_uses[curr->cipher->strength_bits]++;
        curr = curr->next;
    }
    /*
     * Go through the list of used strength_bits values in descending
     * order.
     */
    for (i = max_strength_bits; i >= 0; i--)
        if (number_uses[i] > 0)
            ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, CIPHER_ORD, i,
                                  co_list, head_p, tail_p);

    OPENSSL_free(number_uses);
    return (1);
}

static int ssl_cipher_process_rulestr(const char *rule_str,
                                      CIPHER_ORDER *co_list,
                                      CIPHER_ORDER **head_p,
                                      CIPHER_ORDER **tail_p,
                                      SSL_CIPHER **ca_list)
{
    unsigned long algorithms, mask, algo_strength, mask_strength;
    const char *l, *buf;
    int j, multi, found, rule, retval, ok, buflen;
    unsigned long cipher_id = 0, ssl_version = 0;
    char ch;

    retval = 1;
    l = rule_str;
    for (;;) {
        ch = *l;

        if (ch == '\0')
            break;              /* done */
        if (ch == '-') {
            rule = CIPHER_DEL;
            l++;
        } else if (ch == '+') {
            rule = CIPHER_ORD;
            l++;
        } else if (ch == '!') {
            rule = CIPHER_KILL;
            l++;
        } else if (ch == '@') {
            rule = CIPHER_SPECIAL;
            l++;
        } else {
            rule = CIPHER_ADD;
        }

        if (ITEM_SEP(ch)) {
            l++;
            continue;
        }

        algorithms = mask = algo_strength = mask_strength = 0;

        for (;;) {
            ch = *l;
            buf = l;
            buflen = 0;
#ifndef CHARSET_EBCDIC
            while (((ch >= 'A') && (ch <= 'Z')) ||
                   ((ch >= '0') && (ch <= '9')) ||
                   ((ch >= 'a') && (ch <= 'z')) || (ch == '-'))
#else
            while (isalnum(ch) || (ch == '-'))
#endif
            {
                ch = *(++l);
                buflen++;
            }

            if (buflen == 0) {
                /*
                 * We hit something we cannot deal with,
                 * it is no command or separator nor
                 * alphanumeric, so we call this an error.
                 */
                SSLerr(SSL_F_SSL_CIPHER_PROCESS_RULESTR,
                       SSL_R_INVALID_COMMAND);
                retval = found = 0;
                l++;
                break;
            }

            if (rule == CIPHER_SPECIAL) {
                found = 0;      /* unused -- avoid compiler warning */
                break;          /* special treatment */
            }

            /* check for multi-part specification */
            if (ch == '+') {
                multi = 1;
                l++;
            } else
                multi = 0;

            /*
             * Now search for the cipher alias in the ca_list. Be careful
             * with the strncmp, because the "buflen" limitation
             * will make the rule "ADH:SOME" and the cipher
             * "ADH-MY-CIPHER" look like a match for buflen=3.
             * So additionally check whether the cipher name found
             * has the correct length. We can save a strlen() call:
             * just checking for the '\0' at the right place is
             * sufficient, we have to strncmp() anyway. (We cannot
             * use strcmp(), because buf is not '\0' terminated.)
             */
            j = found = 0;
            cipher_id = 0;
            ssl_version = 0;
            while (ca_list[j]) {
                if (!strncmp(buf, ca_list[j]->name, buflen) &&
                    (ca_list[j]->name[buflen] == '\0')) {
                    found = 1;
                    break;
                } else
                    j++;
            }
            if (!found)
                break;          /* ignore this entry */

            /*-
             * New algorithms:
             *  1 - any old restrictions apply outside new mask
             *  2 - any new restrictions apply outside old mask
             *  3 - enforce old & new where masks intersect
             */
            algorithms = (algorithms & ~ca_list[j]->mask) | /* 1 */
                (ca_list[j]->algorithms & ~mask) | /* 2 */
                (algorithms & ca_list[j]->algorithms); /* 3 */
            mask |= ca_list[j]->mask;
            algo_strength = (algo_strength & ~ca_list[j]->mask_strength) |
                (ca_list[j]->algo_strength & ~mask_strength) |
                (algo_strength & ca_list[j]->algo_strength);
            mask_strength |= ca_list[j]->mask_strength;

            /* explicit ciphersuite found */
            if (ca_list[j]->valid) {
                cipher_id = ca_list[j]->id;
                ssl_version = ca_list[j]->algorithms & SSL_SSL_MASK;
                break;
            }

            if (!multi)
                break;
        }

        /*
         * Ok, we have the rule, now apply it
         */
        if (rule == CIPHER_SPECIAL) { /* special command */
            ok = 0;
            if ((buflen == 8) && !strncmp(buf, "STRENGTH", 8))
                ok = ssl_cipher_strength_sort(co_list, head_p, tail_p);
            else
                SSLerr(SSL_F_SSL_CIPHER_PROCESS_RULESTR,
                       SSL_R_INVALID_COMMAND);
            if (ok == 0)
                retval = 0;
            /*
             * We do not support any "multi" options
             * together with "@", so throw away the
             * rest of the command, if any left, until
             * end or ':' is found.
             */
            while ((*l != '\0') && !ITEM_SEP(*l))
                l++;
        } else if (found) {
            ssl_cipher_apply_rule(cipher_id, ssl_version, algorithms, mask,
                                  algo_strength, mask_strength, rule, -1,
                                  co_list, head_p, tail_p);
        } else {
            while ((*l != '\0') && !ITEM_SEP(*l))
                l++;
        }
        if (*l == '\0')
            break;              /* done */
    }

    return (retval);
}

STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(const SSL_METHOD *ssl_method, STACK_OF(SSL_CIPHER)
                                             **cipher_list, STACK_OF(SSL_CIPHER)
                                             **cipher_list_by_id,
                                             const char *rule_str)
{
    int ok, num_of_ciphers, num_of_alias_max, num_of_group_aliases;
    unsigned long disabled_mask;
    unsigned long disabled_m256;
    STACK_OF(SSL_CIPHER) *cipherstack, *tmp_cipher_list;
    const char *rule_p;
    CIPHER_ORDER *co_list = NULL, *head = NULL, *tail = NULL, *curr;
    SSL_CIPHER **ca_list = NULL;

    /*
     * Return with error if nothing to do.
     */
    if (rule_str == NULL || cipher_list == NULL || cipher_list_by_id == NULL)
        return NULL;

    /*
     * To reduce the work to do we only want to process the compiled
     * in algorithms, so we first get the mask of disabled ciphers.
     */
    {
        struct disabled_masks d;
        d = ssl_cipher_get_disabled();
        disabled_mask = d.mask;
        disabled_m256 = d.m256;
    }

    /*
     * Now we have to collect the available ciphers from the compiled
     * in ciphers. We cannot get more than the number compiled in, so
     * it is used for allocation.
     */
    num_of_ciphers = ssl_method->num_ciphers();
#ifdef KSSL_DEBUG
    printf("ssl_create_cipher_list() for %d ciphers\n", num_of_ciphers);
#endif                          /* KSSL_DEBUG */
    co_list =
        (CIPHER_ORDER *)OPENSSL_malloc(sizeof(CIPHER_ORDER) * num_of_ciphers);
    if (co_list == NULL) {
        SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST, ERR_R_MALLOC_FAILURE);
        return (NULL);          /* Failure */
    }

    ssl_cipher_collect_ciphers(ssl_method, num_of_ciphers, disabled_mask,
                               disabled_m256, co_list, &head, &tail);

    /*
     * We also need cipher aliases for selecting based on the rule_str.
     * There might be two types of entries in the rule_str: 1) names
     * of ciphers themselves 2) aliases for groups of ciphers.
     * For 1) we need the available ciphers and for 2) the cipher
     * groups of cipher_aliases added together in one list (otherwise
     * we would be happy with just the cipher_aliases table).
     */
    num_of_group_aliases = sizeof(cipher_aliases) / sizeof(SSL_CIPHER);
    num_of_alias_max = num_of_ciphers + num_of_group_aliases + 1;
    ca_list =
        (SSL_CIPHER **)OPENSSL_malloc(sizeof(SSL_CIPHER *) *
                                      num_of_alias_max);
    if (ca_list == NULL) {
        OPENSSL_free(co_list);
        SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST, ERR_R_MALLOC_FAILURE);
        return (NULL);          /* Failure */
    }
    ssl_cipher_collect_aliases(ca_list, num_of_group_aliases,
                               (disabled_mask & disabled_m256), head);

    /*
     * If the rule_string begins with DEFAULT, apply the default rule
     * before using the (possibly available) additional rules.
     */
    ok = 1;
    rule_p = rule_str;
    if (strncmp(rule_str, "DEFAULT", 7) == 0) {
        ok = ssl_cipher_process_rulestr(SSL_DEFAULT_CIPHER_LIST,
                                        co_list, &head, &tail, ca_list);
        rule_p += 7;
        if (*rule_p == ':')
            rule_p++;
    }

    if (ok && (strlen(rule_p) > 0))
        ok = ssl_cipher_process_rulestr(rule_p, co_list, &head, &tail,
                                        ca_list);

    OPENSSL_free(ca_list);      /* Not needed anymore */

    if (!ok) {                  /* Rule processing failure */
        OPENSSL_free(co_list);
        return (NULL);
    }
    /*
     * Allocate new "cipherstack" for the result, return with error
     * if we cannot get one.
     */
    if ((cipherstack = sk_SSL_CIPHER_new_null()) == NULL) {
        OPENSSL_free(co_list);
        return (NULL);
    }

    /*
     * The cipher selection for the list is done. The ciphers are added
     * to the resulting precedence to the STACK_OF(SSL_CIPHER).
     */
    for (curr = head; curr != NULL; curr = curr->next) {
#ifdef OPENSSL_FIPS
        if (curr->active
            && (!FIPS_mode() || curr->cipher->algo_strength & SSL_FIPS))
#else
        if (curr->active)
#endif
        {
            sk_SSL_CIPHER_push(cipherstack, curr->cipher);
#ifdef CIPHER_DEBUG
            printf("<%s>\n", curr->cipher->name);
#endif
        }
    }
    OPENSSL_free(co_list);      /* Not needed any longer */

    tmp_cipher_list = sk_SSL_CIPHER_dup(cipherstack);
    if (tmp_cipher_list == NULL) {
        sk_SSL_CIPHER_free(cipherstack);
        return NULL;
    }
    if (*cipher_list != NULL)
        sk_SSL_CIPHER_free(*cipher_list);
    *cipher_list = cipherstack;
    if (*cipher_list_by_id != NULL)
        sk_SSL_CIPHER_free(*cipher_list_by_id);
    *cipher_list_by_id = tmp_cipher_list;
    (void)sk_SSL_CIPHER_set_cmp_func(*cipher_list_by_id,
                                     ssl_cipher_ptr_id_cmp);

    sk_SSL_CIPHER_sort(*cipher_list_by_id);
    return (cipherstack);
}

char *SSL_CIPHER_description(const SSL_CIPHER *cipher, char *buf, int len)
{
    int is_export, pkl, kl;
    const char *ver, *exp_str;
    const char *kx, *au, *enc, *mac;
    unsigned long alg, alg2;
#ifdef KSSL_DEBUG
    static const char *format =
        "%-23s %s Kx=%-8s Au=%-4s Enc=%-9s Mac=%-4s%s AL=%lx\n";
#else
    static const char *format =
        "%-23s %s Kx=%-8s Au=%-4s Enc=%-9s Mac=%-4s%s\n";
#endif                          /* KSSL_DEBUG */

    alg = cipher->algorithms;
    alg2 = cipher->algorithm2;

    is_export = SSL_C_IS_EXPORT(cipher);
    pkl = SSL_C_EXPORT_PKEYLENGTH(cipher);
    kl = SSL_C_EXPORT_KEYLENGTH(cipher);
    exp_str = is_export ? " export" : "";

    if (alg & SSL_SSLV2)
        ver = "SSLv2";
    else if (alg & SSL_SSLV3)
        ver = "SSLv3";
    else
        ver = "unknown";

    switch (alg & SSL_MKEY_MASK) {
    case SSL_kRSA:
        kx = is_export ? (pkl == 512 ? "RSA(512)" : "RSA(1024)") : "RSA";
        break;
    case SSL_kDHr:
        kx = "DH/RSA";
        break;
    case SSL_kDHd:
        kx = "DH/DSS";
        break;
    case SSL_kKRB5:            /* VRS */
    case SSL_KRB5:             /* VRS */
        kx = "KRB5";
        break;
    case SSL_kFZA:
        kx = "Fortezza";
        break;
    case SSL_kEDH:
        kx = is_export ? (pkl == 512 ? "DH(512)" : "DH(1024)") : "DH";
        break;
    case SSL_kECDH:
    case SSL_kECDHE:
        kx = is_export ? "ECDH(<=163)" : "ECDH";
        break;
    default:
        kx = "unknown";
    }

    switch (alg & SSL_AUTH_MASK) {
    case SSL_aRSA:
        au = "RSA";
        break;
    case SSL_aDSS:
        au = "DSS";
        break;
    case SSL_aDH:
        au = "DH";
        break;
    case SSL_aKRB5:            /* VRS */
    case SSL_KRB5:             /* VRS */
        au = "KRB5";
        break;
    case SSL_aFZA:
    case SSL_aNULL:
        au = "None";
        break;
    case SSL_aECDSA:
        au = "ECDSA";
        break;
    default:
        au = "unknown";
        break;
    }

    switch (alg & SSL_ENC_MASK) {
    case SSL_DES:
        enc = (is_export && kl == 5) ? "DES(40)" : "DES(56)";
        break;
    case SSL_3DES:
        enc = "3DES(168)";
        break;
    case SSL_RC4:
        enc = is_export ? (kl == 5 ? "RC4(40)" : "RC4(56)")
            : ((alg2 & SSL2_CF_8_BYTE_ENC) ? "RC4(64)" : "RC4(128)");
        break;
    case SSL_RC2:
        enc = is_export ? (kl == 5 ? "RC2(40)" : "RC2(56)") : "RC2(128)";
        break;
    case SSL_IDEA:
        enc = "IDEA(128)";
        break;
    case SSL_eFZA:
        enc = "Fortezza";
        break;
    case SSL_eNULL:
        enc = "None";
        break;
    case SSL_AES:
        switch (cipher->strength_bits) {
        case 128:
            enc = "AES(128)";
            break;
        case 192:
            enc = "AES(192)";
            break;
        case 256:
            enc = "AES(256)";
            break;
        default:
            enc = "AES(?" "?" "?)";
            break;
        }
        break;
    case SSL_CAMELLIA:
        switch (cipher->strength_bits) {
        case 128:
            enc = "Camellia(128)";
            break;
        case 256:
            enc = "Camellia(256)";
            break;
        default:
            enc = "Camellia(?" "?" "?)";
            break;
        }
        break;
    case SSL_SEED:
        enc = "SEED(128)";
        break;

    default:
        enc = "unknown";
        break;
    }

    switch (alg & SSL_MAC_MASK) {
    case SSL_MD5:
        mac = "MD5";
        break;
    case SSL_SHA1:
        mac = "SHA1";
        break;
    default:
        mac = "unknown";
        break;
    }

    if (buf == NULL) {
        len = 128;
        buf = OPENSSL_malloc(len);
        if (buf == NULL)
            return ("OPENSSL_malloc Error");
    } else if (len < 128)
        return ("Buffer too small");

#ifdef KSSL_DEBUG
    BIO_snprintf(buf, len, format, cipher->name, ver, kx, au, enc, mac,
                 exp_str, alg);
#else
    BIO_snprintf(buf, len, format, cipher->name, ver, kx, au, enc, mac,
                 exp_str);
#endif                          /* KSSL_DEBUG */
    return (buf);
}

char *SSL_CIPHER_get_version(const SSL_CIPHER *c)
{
    int i;

    if (c == NULL)
        return ("(NONE)");
    i = (int)(c->id >> 24L);
    if (i == 3)
        return ("TLSv1/SSLv3");
    else if (i == 2)
        return ("SSLv2");
    else
        return ("unknown");
}

/* return the actual cipher being used */
const char *SSL_CIPHER_get_name(const SSL_CIPHER *c)
{
    if (c != NULL)
        return (c->name);
    return ("(NONE)");
}

/* number of bits for symmetric cipher */
int SSL_CIPHER_get_bits(const SSL_CIPHER *c, int *alg_bits)
{
    int ret = 0;

    if (c != NULL) {
        if (alg_bits != NULL)
            *alg_bits = c->alg_bits;
        ret = c->strength_bits;
    }
    return (ret);
}

SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n)
{
    SSL_COMP *ctmp;
    int i, nn;

    if ((n == 0) || (sk == NULL))
        return (NULL);
    nn = sk_SSL_COMP_num(sk);
    for (i = 0; i < nn; i++) {
        ctmp = sk_SSL_COMP_value(sk, i);
        if (ctmp->id == n)
            return (ctmp);
    }
    return (NULL);
}

#ifdef OPENSSL_NO_COMP
void *SSL_COMP_get_compression_methods(void)
{
    return NULL;
}

int SSL_COMP_add_compression_method(int id, void *cm)
{
    return 1;
}

const char *SSL_COMP_get_name(const void *comp)
{
    return NULL;
}
#else
STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void)
{
    load_builtin_compressions();
    return (ssl_comp_methods);
}

int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm)
{
    SSL_COMP *comp;

    if (cm == NULL || cm->type == NID_undef)
        return 1;

    /*-
     * According to draft-ietf-tls-compression-04.txt, the
     * compression number ranges should be the following:
     *
     *   0 to  63:  methods defined by the IETF
     *  64 to 192:  external party methods assigned by IANA
     * 193 to 255:  reserved for private use
     */
    if (id < 193 || id > 255) {
        SSLerr(SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD,
               SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE);
        return 0;
    }

    MemCheck_off();
    comp = (SSL_COMP *)OPENSSL_malloc(sizeof(SSL_COMP));
    comp->id = id;
    comp->method = cm;
    load_builtin_compressions();
    if (ssl_comp_methods && sk_SSL_COMP_find(ssl_comp_methods, comp) >= 0) {
        OPENSSL_free(comp);
        MemCheck_on();
        SSLerr(SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD,
               SSL_R_DUPLICATE_COMPRESSION_ID);
        return (1);
    } else if ((ssl_comp_methods == NULL)
               || !sk_SSL_COMP_push(ssl_comp_methods, comp)) {
        OPENSSL_free(comp);
        MemCheck_on();
        SSLerr(SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD, ERR_R_MALLOC_FAILURE);
        return (1);
    } else {
        MemCheck_on();
        return (0);
    }
}

const char *SSL_COMP_get_name(const COMP_METHOD *comp)
{
    if (comp)
        return comp->name;
    return NULL;
}

#endif


text:
class AddDefaultPadToUserEvent < ActiveRecord::Migration[5.0]
  def up
    change_column_default :user_events, :paid, false
    UserEvent.find_each do |ue|
      if ue.paid.nil?
        ue.paid = false
        ue.save!
      end
    end
  end
end

redpajama_set_name: RedPajamaGithub


text:
// Copyright (C) 2017 Luca Piccioni
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

using System;

using Khronos;

using NUnit.Framework;

namespace OpenGL.Test
{
	[TestFixture, Category("Framework")]
	class RemovedByFeatureAttributeTest
	{
		[Test(Description = "Test RemovedByFeatureAttribute(string featureName)")]
		[TestCase("GL_VERSION_1_0", 1, 0, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_1_1", 1, 1, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_1_2", 1, 2, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_1_3", 1, 3, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_1_4", 1, 4, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_1_5", 1, 5, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_2_0", 2, 0, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_2_1", 2, 1, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_3_0", 3, 0, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_3_1", 3, 1, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_3_2", 3, 2, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_4_0", 4, 0, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_4_1", 4, 1, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_4_2", 4, 2, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_4_3", 4, 3, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_4_4", 4, 4, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_4_5", 4, 5, 0, KhronosVersion.ApiGl)]
		[TestCase("GL_VERSION_ES_CM_1_0", 1, 0, 0, KhronosVersion.ApiGles1)]
		[TestCase("GL_ES_VERSION_2_0", 2, 0, 0, KhronosVersion.ApiGles2)]
		[TestCase("GL_ES_VERSION_3_0", 3, 0, 0, KhronosVersion.ApiGles2)]
		[TestCase("GL_ES_VERSION_3_1", 3, 1, 0, KhronosVersion.ApiGles2)]
		[TestCase("GL_ES_VERSION_3_2", 3, 2, 0, KhronosVersion.ApiGles2)]
		[TestCase("GL_SC_VERSION_2_0", 2, 0, 0, KhronosVersion.ApiGlsc2)]
		public void RemovedByFeatureAttribute_Constructor1(string feature, int major, int minor, int revision, string api)
		{
			RemovedByFeatureAttribute a = new RemovedByFeatureAttribute(feature);

			Assert.AreEqual(feature, a.FeatureName);
			Assert.IsNotNull(a.FeatureVersion);
			Assert.AreEqual(new KhronosVersion(major, minor, revision, api), a.FeatureVersion);
			Assert.IsNull(a.FeatureVersion.Profile);

			// a.Api does not follow a.FeatureVersion.Api: code generator must always specify Api explictly
			Assert.AreEqual(KhronosVersion.ApiGl, a.Api);
		}

		[Test(Description = "Test RemovedByFeatureAttribute(string featureName)")]
		[TestCase("GL_3DFX_multisample")]
		[TestCase("GL_ARB_multisample")]
		[TestCase("AnythingThanFeatures")]
		public void RemovedByFeatureAttribute_Constructor2(string feature)
		{
			RemovedByFeatureAttribute a = new RemovedByFeatureAttribute(feature);

			Assert.AreEqual(feature, a.FeatureName);
			Assert.IsNull(a.FeatureVersion);
			Assert.IsNull(a.Profile);

			// a.Api does not follow a.FeatureVersion.Api: code generator must always specify Api explictly
			Assert.AreEqual(KhronosVersion.ApiGl, a.Api);
		}

		[Test(Description = "Test RemovedByFeatureAttribute(string featureName) ArgumentException")]
		[TestCase(null)]
		[TestCase("")]
		public void RemovedByFeatureAttribute_Constructor1_ArgumentException(string feature)
		{
			Assert.Throws<ArgumentException>(() => new RemovedByFeatureAttribute(feature));
		}

		[Test(Description = "Test IsRemoved(KhronosVersion version, KhronosApi.ExtensionsCollection extensions)")]
		public void RemovedByFeatureAttribute_IsRemoved()
		{
			RemovedByFeatureAttribute a;

			// Version
			a = new RemovedByFeatureAttribute("GL_VERSION_1_1");
			Assert.IsTrue(a.IsRemoved(Gl.Version_110, null));
			Assert.IsFalse(a.IsRemoved(Gl.Version_100, null));

			// All versions greater than the requirement are supported
			Assert.IsTrue(a.IsRemoved(Gl.Version_120, null));
			Assert.IsTrue(a.IsRemoved(Gl.Version_200, null));
			Assert.IsTrue(a.IsRemoved(Gl.Version_450, null));

			// a.FeatureVersion.Profile is null: any profile match
			Assert.IsTrue(a.IsRemoved(new KhronosVersion(Gl.Version_110, KhronosVersion.ProfileCompatibility), null));

			a = new RemovedByFeatureAttribute("GL_VERSION_3_2");
			a.Profile = KhronosVersion.ProfileCompatibility;

			// a.FeatureVersion.Profile is not null: specific profile match...
			Assert.IsTrue(a.IsRemoved(new KhronosVersion(Gl.Version_320, KhronosVersion.ProfileCompatibility), null));
			Assert.IsFalse(a.IsRemoved(new KhronosVersion(Gl.Version_320, KhronosVersion.ProfileCore), null));
			// ...and even unspecified profile
			Assert.IsTrue(a.IsRemoved(new KhronosVersion(Gl.Version_320, null), null));

			// a.Api must match (no regex)
			Assert.IsFalse(a.IsRemoved(new KhronosVersion(Gl.Version_320_ES, KhronosVersion.ProfileCore), null));

			// Extension
			a = new RemovedByFeatureAttribute("GL_ARB_multisample");
			Assert.IsFalse(a.IsRemoved(new KhronosVersion(Gl.Version_320, KhronosVersion.ProfileCore), null));

			Gl.Extensions extensions = new Gl.Extensions();

			Assert.IsFalse(a.IsRemoved(new KhronosVersion(Gl.Version_320, KhronosVersion.ProfileCore), extensions));

			extensions.EnableExtension("GL_ARB_multisample");
			Assert.IsTrue(a.IsRemoved(new KhronosVersion(Gl.Version_320, KhronosVersion.ProfileCore), extensions));
			// Note: extensions.MultisampleARB is not altered by EnableExtension

			// Version/Profile
			a = new RemovedByFeatureAttribute("GL_VERSION_3_2");
			a.Profile = "core|compatibility";
			Assert.IsTrue(a.IsRemoved(new KhronosVersion(Gl.Version_320, KhronosVersion.ProfileCore), null));
			Assert.IsTrue(a.IsRemoved(new KhronosVersion(Gl.Version_320, KhronosVersion.ProfileCompatibility), null));
			Assert.IsFalse(a.IsRemoved(new KhronosVersion(Gl.Version_320, KhronosVersion.ProfileCommon), null));
		}

		[Test(Description = "Test IsSupported(KhronosVersion version, KhronosApi.ExtensionsCollection extensions) ArgumentNullException")]
		public void RemovedByFeatureAttribute_IsSupported_ArgumentNullException()
		{
			RemovedByFeatureAttribute a = new RemovedByFeatureAttribute("GL_VERSION_1_0");
			Gl.Extensions extensions = new Gl.Extensions();

			Assert.DoesNotThrow(() => a.IsRemoved(Gl.Version_100, extensions));
			Assert.DoesNotThrow(() => a.IsRemoved(Gl.Version_100, null));

			Assert.Throws<ArgumentNullException>(() => a.IsRemoved(null, extensions));
		}
	}
}


text:
package client.bluerhino.cn.lib_image.imagebrowse.photoselector.ui;
/**
 * @author Aizaz AZ
 */

import android.os.Bundle;

import java.util.List;

import client.bluerhino.cn.lib_image.imagebrowse.photoselector.domain.PhotoSelectorDomain;
import client.bluerhino.cn.lib_image.imagebrowse.photoselector.model.PhotoModel;
import client.bluerhino.cn.lib_image.imagebrowse.photoselector.ui.PhotoSelectorActivity.OnLocalReccentListener;
import client.bluerhino.cn.lib_image.imagebrowse.photoselector.util.CommonUtils;

public class PhotoPreviewActivity extends BasePhotoPreviewActivity implements OnLocalReccentListener {

    private PhotoSelectorDomain photoSelectorDomain;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        photoSelectorDomain = new PhotoSelectorDomain(getApplicationContext());

        init(getIntent().getExtras());
    }

    @SuppressWarnings("unchecked")
    protected void init(Bundle extras) {
        if (extras == null)
            return;

        if (extras.containsKey("photos")) { // 预览图片
            photos = (List<PhotoModel>) extras.getSerializable("photos");
            current = extras.getInt("position", 0);
            updatePercent();
            bindData();
        } else if (extras.containsKey("album")) { // 点击图片查看
            String albumName = extras.getString("album"); // 相册
            this.current = extras.getInt("position");
            if (!CommonUtils.isNull(albumName) && albumName.equals(PhotoSelectorActivity.RECCENT_PHOTO)) {
                photoSelectorDomain.getReccent(this);
            } else {
                photoSelectorDomain.getAlbum(albumName, this);
            }
        }
    }

    @Override
    public void onPhotoLoaded(List<PhotoModel> photos) {
        this.photos = photos;
        updatePercent();
        bindData(); // 更新界面
    }

}


text:
define([
    'foreground/model/exportPlaylist',
    'foreground/view/prompt/exportPlaylistPromptView',
    'test/testUtility'
], function (ExportPlaylist, ExportPlaylistPromptView, TestUtility) {
    'use strict';

    describe('ExportPlaylistPromptView', function () {
        beforeEach(function () {
            this.documentFragment = document.createDocumentFragment();
            this.view = new ExportPlaylistPromptView({
                model: new ExportPlaylist({
                    playlist: TestUtility.buildPlaylist()
                })
            });
        });

        afterEach(function () {
            this.view.destroy();
        });

        it('should show', function (done) {
            this.documentFragment.appendChild(this.view.render().el);
            //  Wait before removing the element because destroying the view immediately causes race-condition error due to expectance of HTML presence in _transitionIn
            this.view.onVisible = done;
            this.view.triggerMethod('show');
        });

        describe('onSubmit', function () {
            it('should export its playlist', function () {
                sinon.stub(this.view.contentView, 'saveAndExport');

                this.view.onSubmit();
                expect(this.view.contentView.saveAndExport.calledOnce).to.equal(true);

                this.view.contentView.saveAndExport.restore();
            });
        });
    });
});


text:
'use strict';

module.exports = function (grunt) {
    grunt.initConfig({
        prepare_build : {
            prepare : {
                options : {
                    versionFile : '../../tmp/test/fixtures/VERSION_PATCH.js',
                    increasePatch : true
                }
            }
        }
    });

    grunt.loadTasks('../../tasks');

    grunt.registerTask('default', ['prepare_build']);
};


text:
package org.apache.commons.validator.routines.checkdigit;

/**
 * Modulus 10 ISIN (International Securities Identifying Number) Check Digit calculation/validation.
 *
 *

 * ISIN Numbers are 12 character alphanumeric codes used
 * to identify Securities.
 *

 *
 *

 * Check digit calculation uses the Modulus 10 Double Add Double technique
 * with every second digit being weighted by 2. Alphabetic characters are
 * converted to numbers by their position in the alphabet starting with A being 10.
 * Weighted numbers greater than ten are treated as two separate numbers.
 *

 *
 *

 * See Wikipedia - ISIN
 * for more details.
 *

 *
 * @since 1.4
 */
public final class ISINCheckDigit extends ModulusCheckDigit {

    private static final long serialVersionUID = -1239211208101323599L;

    private static final int MAX_ALPHANUMERIC_VALUE = 35; // Character.getNumericValue('Z')

    /** Singleton ISIN Check Digit instance */
    public static final CheckDigit ISIN_CHECK_DIGIT = new ISINCheckDigit();

    /** weighting given to digits depending on their right position */
    private static final int[] POSITION_WEIGHT = {2, 1};

    /**
     * Construct an ISIN Indetifier Check Digit routine.
     */
    public ISINCheckDigit() {
        super(10); // CHECKSTYLE IGNORE MagicNumber
    }

    /**
     * Calculate the modulus for an ISIN code.
     *
     * @param code The code to calculate the modulus for.
     * @param includesCheckDigit Whether the code includes the Check Digit or not.
     * @return The modulus value
     * @throws CheckDigitException if an error occurs calculating the modulus
     * for the specified code
     */
    @Override
    protected int calculateModulus(final String code, final boolean includesCheckDigit) throws CheckDigitException {
        final StringBuilder transformed = new  StringBuilder(code.length() * 2); // CHECKSTYLE IGNORE MagicNumber
        if (includesCheckDigit) {
            final char checkDigit = code.charAt(code.length()-1); // fetch the last character
            if (!Character.isDigit(checkDigit)){
                throw new CheckDigitException("Invalid checkdigit["+ checkDigit+ "] in " + code);
            }
        }
        for (int i = 0; i < code.length(); i++) {
            final int charValue = Character.getNumericValue(code.charAt(i));
            if (charValue < 0 || charValue > MAX_ALPHANUMERIC_VALUE) {
                throw new CheckDigitException("Invalid Character[" +
                        (i + 1) + "] = '" + charValue + "'");
            }
             // this converts alphanumerics to two digits
             // so there is no need to overload toInt()
            transformed.append(charValue);
        }
        return super.calculateModulus(transformed.toString(), includesCheckDigit);
    }

    /**
     *
Calculates the weighted value of a charcter in the
     * code at a specified position.

     *
     *
For ISIN (from right to left) odd digits are weighted
     * with a factor of one and even digits with a factor
     * of two. Weighted values are reduced to their digital root

     *
     * @param charValue The numeric value of the character.
     * @param leftPos  The position of the character in the code, counting from left to right
     * @param rightPos The position of the character in the code, counting from right to left
     * @return The weighted value of the character.
     */
    @Override
    protected int weightedValue(final int charValue, final int leftPos, final int rightPos) {
        final int weight = POSITION_WEIGHT[rightPos % 2]; // CHECKSTYLE IGNORE MagicNumber
        final int weightedValue = charValue * weight;
        return ModulusCheckDigit.sumDigits(weightedValue);
    }
}


text: Git repository to hold all the interview questions I encounter.


text:
<!DOCTYPE html><html><head><meta charset="utf-8" />
<meta http-equiv="refresh" content="0;url=/place/croatia/emissions/" />
</head></html>


text:
package com.fasterxml.aalto.sax;

import com.fasterxml.aalto.AaltoInputProperties;

public class TestSAXParserFactoryImpl extends base.BaseTestCase
{
    // [aalto-xml#65]
    public void testSetGetFeatureExternalGeneralEntities() throws Exception
    {
        SAXParserFactoryImpl saxParserFactory = new SAXParserFactoryImpl();
        assertFalse(saxParserFactory.getFeature(AaltoInputProperties.P_RETAIN_ATTRIBUTE_GENERAL_ENTITIES));

        saxParserFactory.setFeature(AaltoInputProperties.P_RETAIN_ATTRIBUTE_GENERAL_ENTITIES, true);
        assertTrue(saxParserFactory.getFeature(AaltoInputProperties.P_RETAIN_ATTRIBUTE_GENERAL_ENTITIES));
    }

}


text:
@interface CTLInsetTextFieldViewController : UIViewController

@end


text:
<?php

namespace App\Common\Models\Weixin2\Miniprogram\Qrcode;

use App\Common\Models\Base\Base;

class Qrcode extends Base
{

    function __construct()
    {
        $this->setModel(new \App\Common\Models\Weixin2\Mysql\Miniprogram\Qrcode\Qrcode());
    }
}


text:
{-# LANGUAGE OverloadedStrings #-}
-- | Add <http://www.w3.org/TR/cors/ CORS> (cross-origin resource sharing)
-- headers to a Snap application. CORS headers can be added either conditionally
-- or unconditionally to the entire site, or you can apply CORS headers to a
-- single route.
--
-- To use in a snaplet, simply use 'wrapSite':
--
-- @
-- wrapSite $ applyCORS defaultOptions
-- @
module Snap.Util.CORS
  ( -- * Applying CORS to a specific response
    applyCORS

    -- * Option Specification
  , CORSOptions(..)
  , defaultOptions

    -- ** Origin lists
  , OriginList(..)
  , OriginSet, mkOriginSet, origins

    -- * Internals
  , HashableURI(..), HashableMethod (..)
  ) where

import Control.Applicative
import Control.Monad (join, when)
import Data.CaseInsensitive (CI)
import Data.Hashable (Hashable(..))
import Data.Maybe (fromMaybe)
import Data.Text.Encoding (decodeUtf8, encodeUtf8)
import Network.URI (URI (..), URIAuth (..),  parseURI)

import qualified Data.Attoparsec.ByteString.Char8 as Attoparsec
import qualified Data.ByteString.Char8 as S
import qualified Data.CaseInsensitive as CI
import qualified Data.HashSet as HashSet
import qualified Data.Text as Text

import qualified Snap.Core as Snap
import Snap.Internal.Parsing (pTokens)

-- | A set of origins. RFC 6454 specifies that origins are a scheme, host and
-- port, so the 'OriginSet' wrapper around a 'HashSet.HashSet' ensures that each
-- 'URI' constists of nothing more than this.
newtype OriginSet = OriginSet { origins :: HashSet.HashSet HashableURI }

-- | Used to specify the contents of the @Access-Control-Allow-Origin@ header.
data OriginList
  = Everywhere
  -- ^ Allow any origin to access this resource. Corresponds to
  -- @Access-Control-Allow-Origin: *@
  | Nowhere
  -- ^ Do not allow cross-origin requests
  | Origins OriginSet
  -- ^ Allow cross-origin requests from these origins.

-- | Specify the options to use when building CORS headers for a response. Most
-- of these options are 'Snap.Handler' actions to allow you to conditionally
-- determine the setting of each header.
data CORSOptions m = CORSOptions
  { corsAllowOrigin :: m OriginList
  -- ^ Which origins are allowed to make cross-origin requests.

  , corsAllowCredentials :: m Bool
  -- ^ Whether or not to allow exposing the response when the omit credentials
  -- flag is unset.

  , corsExposeHeaders :: m (HashSet.HashSet (CI S.ByteString))
  -- ^ A list of headers that are exposed to clients. This allows clients to
  -- read the values of these headers, if the response includes them.

  , corsAllowedMethods :: m (HashSet.HashSet HashableMethod)
  -- ^ A list of request methods that are allowed.

  , corsAllowedHeaders :: HashSet.HashSet S.ByteString -> m (HashSet.HashSet S.ByteString)
  -- ^ An action to determine which of the request headers are allowed.
  -- This action is supplied the parsed contents of
  -- @Access-Control-Request-Headers@.
  }

-- | Liberal default options. Specifies that:
--
-- * All origins may make cross-origin requests
-- * @allow-credentials@ is true.
-- * No extra headers beyond simple headers are exposed.
-- * @GET@, @POST@, @PUT@, @DELETE@ and @HEAD@ are all allowed.
-- * All request headers are allowed.
--
-- All options are determined unconditionally.
defaultOptions :: Monad m => CORSOptions m
defaultOptions = CORSOptions
  { corsAllowOrigin = return Everywhere
  , corsAllowCredentials = return True
  , corsExposeHeaders = return HashSet.empty
  , corsAllowedMethods = return $! defaultAllowedMethods
  , corsAllowedHeaders = return
  }

defaultAllowedMethods :: HashSet.HashSet HashableMethod
defaultAllowedMethods = HashSet.fromList $ map HashableMethod
        [ Snap.GET, Snap.POST, Snap.PUT, Snap.DELETE, Snap.HEAD ]

-- | Apply CORS headers to a specific request. This is useful if you only have
-- a single action that needs CORS headers, and you don't want to pay for
-- conditional checks on every request.
--
-- You should note that 'applyCORS' needs to be used before you add any
-- 'Snap.method' combinators. For example, the following won't do what you want:
--
-- > method POST $ applyCORS defaultOptions $ myHandler
--
-- This fails to work as CORS requires an @OPTIONS@ request in the preflighting
-- stage, but this would get filtered out. Instead, use
--
-- > applyCORS defaultOptions $ method POST $ myHandler
applyCORS :: Snap.MonadSnap m => CORSOptions m -> m () -> m ()
applyCORS options m =
  (join . fmap decodeOrigin <$> getHeader "Origin") >>= maybe m corsRequestFrom

 where
  corsRequestFrom origin = do
    originList <- corsAllowOrigin options
    if origin `inOriginList` originList
       then Snap.method Snap.OPTIONS (preflightRequestFrom origin)
              <|> handleRequestFrom origin
       else m

  preflightRequestFrom origin = do
    maybeMethod <- fmap (parseMethod . S.unpack) <$>
                     getHeader "Access-Control-Request-Method"

    case maybeMethod of
      Nothing -> m

      Just method -> do
        allowedMethods <- corsAllowedMethods options

        if method `HashSet.member` allowedMethods
          then do
            maybeHeaders <-
              fromMaybe (Just HashSet.empty) . fmap splitHeaders
                <$> getHeader "Access-Control-Request-Headers"

            case maybeHeaders of
              Nothing -> m
              Just headers -> do
                allowedHeaders <- corsAllowedHeaders options headers

                if not $ HashSet.null $
                     headers `HashSet.difference` allowedHeaders
                   then m
                   else do
                     addAccessControlAllowOrigin origin
                     addAccessControlAllowCredentials

                     commaSepHeader
                       "Access-Control-Allow-Headers"
                       id (HashSet.toList allowedHeaders)

                     commaSepHeader
                       "Access-Control-Allow-Methods"
                       (S.pack . show) (HashSet.toList allowedMethods)

          else m

  handleRequestFrom origin = do
    addAccessControlAllowOrigin origin
    addAccessControlAllowCredentials

    exposeHeaders <- corsExposeHeaders options
    when (not $ HashSet.null exposeHeaders) $
      commaSepHeader
        "Access-Control-Expose-Headers"
        CI.original (HashSet.toList exposeHeaders)

    m

  addAccessControlAllowOrigin origin =
    addHeader "Access-Control-Allow-Origin"
              (encodeUtf8 $ Text.pack $ show origin)

  addAccessControlAllowCredentials = do
    allowCredentials <- corsAllowCredentials options
    when (allowCredentials) $
      addHeader "Access-Control-Allow-Credentials" "true"

  decodeOrigin :: S.ByteString -> Maybe URI
  decodeOrigin = fmap simplifyURI . parseURI . Text.unpack . decodeUtf8

  addHeader k v = Snap.modifyResponse (Snap.addHeader k v)

  commaSepHeader k f vs =
    case vs of
      [] -> return ()
      _  -> addHeader k $ S.intercalate ", " (map f vs)

  getHeader = Snap.getsRequest . Snap.getHeader

  splitHeaders = either (const Nothing) (Just . HashSet.fromList) .
    Attoparsec.parseOnly pTokens

mkOriginSet :: [URI] -> OriginSet
mkOriginSet = OriginSet . HashSet.fromList .
              map (HashableURI . simplifyURI)

simplifyURI :: URI -> URI
simplifyURI uri = uri { uriAuthority =
                          fmap simplifyURIAuth (uriAuthority uri)
                       , uriPath = ""
                       , uriQuery = ""
                       , uriFragment = ""
                       }
 where simplifyURIAuth auth = auth { uriUserInfo = "" }

--------------------------------------------------------------------------------
parseMethod :: String -> HashableMethod
parseMethod "GET"     = HashableMethod Snap.GET
parseMethod "POST"    = HashableMethod Snap.POST
parseMethod "HEAD"    = HashableMethod Snap.HEAD
parseMethod "PUT"     = HashableMethod Snap.PUT
parseMethod "DELETE"  = HashableMethod Snap.DELETE
parseMethod "TRACE"   = HashableMethod Snap.TRACE
parseMethod "OPTIONS" = HashableMethod Snap.OPTIONS
parseMethod "CONNECT" = HashableMethod Snap.CONNECT
parseMethod "PATCH"   = HashableMethod Snap.PATCH
parseMethod s         = HashableMethod $ Snap.Method (S.pack s)

--------------------------------------------------------------------------------
-- | A @newtype@ over 'URI' with a 'Hashable' instance.
newtype HashableURI = HashableURI URI
  deriving (Eq)

instance Show HashableURI where
  show (HashableURI u) = show u

instance Hashable HashableURI where
  hashWithSalt s (HashableURI (URI scheme authority path query fragment)) =
    s `hashWithSalt`
    scheme `hashWithSalt`
    fmap hashAuthority authority `hashWithSalt`
    path `hashWithSalt`
    query `hashWithSalt`
    fragment

   where
    hashAuthority (URIAuth userInfo regName port) =
          s `hashWithSalt`
          userInfo `hashWithSalt`
          regName `hashWithSalt`
          port

inOriginList :: URI -> OriginList -> Bool
_ `inOriginList` Nowhere = False
_ `inOriginList` Everywhere = True
origin `inOriginList` (Origins (OriginSet xs)) =
  HashableURI origin `HashSet.member` xs

--------------------------------------------------------------------------------
newtype HashableMethod = HashableMethod Snap.Method
  deriving (Eq)

instance Hashable HashableMethod where
  hashWithSalt s (HashableMethod Snap.GET)        = s `hashWithSalt` (0 :: Int)
  hashWithSalt s (HashableMethod Snap.HEAD)       = s `hashWithSalt` (1 :: Int)
  hashWithSalt s (HashableMethod Snap.POST)       = s `hashWithSalt` (2 :: Int)
  hashWithSalt s (HashableMethod Snap.PUT)        = s `hashWithSalt` (3 :: Int)
  hashWithSalt s (HashableMethod Snap.DELETE)     = s `hashWithSalt` (4 :: Int)
  hashWithSalt s (HashableMethod Snap.TRACE)      = s `hashWithSalt` (5 :: Int)
  hashWithSalt s (HashableMethod Snap.OPTIONS)    = s `hashWithSalt` (6 :: Int)
  hashWithSalt s (HashableMethod Snap.CONNECT)    = s `hashWithSalt` (7 :: Int)
  hashWithSalt s (HashableMethod Snap.PATCH)      = s `hashWithSalt` (8 :: Int)
  hashWithSalt s (HashableMethod (Snap.Method m)) =
    s `hashWithSalt` (9 :: Int) `hashWithSalt` m

instance Show HashableMethod where
  show (HashableMethod m) = show m


text:
/*	$NetBSD: memeccreg.h,v 1.1 1998/09/18 20:18:10 pk Exp $	*/

/*-
 * Copyright (c) 1998 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Paul Kranenburg.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *        This product includes software developed by the NetBSD
 *        Foundation, Inc. and its contributors.
 * 4. Neither the name of The NetBSD Foundation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * ECC memory control.
 */

/* Register offsets */
#define ECC_EN_REG	0
#define ECC_FSR_REG	8
#define ECC_AFR0_REG	16
#define ECC_AFR1_REG	20
#define ECC_DIAG_REG	24

/* ECC Memory Enable register */
#define ECC_EN_EE	0x00000001	/* Enable ECC checking */
#define ECC_EN_EI	0x00000002	/* Interrupt on correctable error */
#define ECC_EN_VER	0x0f000000	/* Version */
#define ECC_EN_IMPL	0xf0000000	/* Implementation Id */

/* ECC Memory Fault Status register */
#define ECC_FSR_CE	0x00000001	/* Correctable error */
#define ECC_FSR_TO	0x00000004	/* Timeout on write */
#define ECC_FSR_UE	0x00000008	/* Uncorrectable error */
#define ECC_FSR_DW	0x000000f0	/* Index of double word in block */
#define ECC_FSR_SYND	0x0000ff00	/* Syndrome for correctable error */
#define ECC_FSR_ME	0x00010000	/* Multiple errors */
#define ECC_FSR_BITS	"\177\020"				\
			"b\0CE\0b\2TO\0b\3UE\0"			\
			"f\4\4DW\0f\10\10SYNDROME\0b\20ME\0"

/*
 * ECC Memory Fault Address registers
 * There are two of these. The first has bits 32-35 of the faulting
 * physical address and assorted MBus bits. The second has bits
 * 0-31 of the faulting physical address.
 */
#define ECC_AFR_PAH	0x0000000f	/* PA[31-35] */
#define ECC_AFR_TYPE	0x000000f0	/* Transaction type */
#define ECC_AFR_SIZE	0x00000700	/* Transaction size */
#define ECC_AFR_C	0x00000800	/* Mapped cacheable */
#define ECC_AFR_LOCK	0x00001000	/* Error occurred in atomic cycle */
#define ECC_AFR_MBL	0x00002000	/* Boot mode */
#define ECC_AFR_VA	0x003fc000	/* VA[12-19] (superset bits) */
#define ECC_AFR_S	0x08000000	/* Access was in supervisor mode */
#define ECC_AFR_MID	0xf0000000	/* Module code */
#define ECC_AFR_BITS	"\177\020"				\
			"f\0\4VAH\0f\4\4TYPE\0f\10\3SIZE\0"	\
			"b\13C\0b\14LOCK\0b\15MBL\0"		\
			"f\16\10VA\0b\33S\0f\34\4MID\0"

/* ECC Diagnostic register */
#define ECC_DR_CBX	0x00000001
#define ECC_DR_CB0	0x00000002
#define ECC_DR_CB1	0x00000004
#define ECC_DR_CB2	0x00000008
#define ECC_DR_CB4	0x00000010
#define ECC_DR_CB8	0x00000020
#define ECC_DR_CB16	0x00000040
#define ECC_DR_CB32	0x00000080
#define ECC_DR_DMODE	0x00000c00
#define ECC_DR_BITS	"\177\020"					\
			"f\12\2DMODE\0=\0NORMAL\0=\1GEN\0=\2DETECT\0"	\
			"f\0\8CHECK BITS\0"


text:
<?php
use CLMVC\Core\Container;
use CLMVC\ViewEngines\WordPress\WpEngine;
use CLMVC\ViewEngines\WordPress\WpRendering;

define('CLOUDLESS_APP_DIR', WP_PLUGIN_DIR);

Container::instance()->fetchOrMake(WpEngine::class)->init();
Container::instance()->fetchOrMake(WpRendering::class)->init();

/**
 * @param string $app
 * @param string $url
 *
 * @return string
 */
if (!function_exists('clmvc_app_url')) {

    /**
     * @return string
     */
    function clmvc_app_url($app, $url)
    {
        return plugins_url($app.'/'.$url);
    }
}


text:
.386
.model flat,stdcall
option casemap:none
__UNICODE__ equ 1
;
;
;
include windows.inc
include user32.inc
include kernel32.inc
include gdi32.inc
includelib user32.lib
includelib kernel32.lib
includelib gdi32.lib
;
;
;
ICO_MAIN equ 1000h
ID_TIMER equ 1
;
;
;
.data?
hInstance dd ?
hWinMain dd ?
dwCenterX dd ?
dwCenterY dd ?
dwRadius dd ?
.const
szClassName db 'Bmp Clock',0
;
;
;
.code
;
;
;
_CalcClockParam proc
local @stRect:RECT

invoke GetClientRect,hWinMain,addr @stRect
mov eax,@stRect.right
sub eax,@stRect.left
mov ecx,@stRect.bottom
sub ecx,@stRect.top
;
;
;
.if ecx>eax
    mov edx,eax
    sub ecx,eax
    shr ecx,1
    mov dwCenterX,0
    mov dwCenterY,ecx
.else
    mov edx,ecx
    sub eax,ecx
    shr eax,1
    mov dwCenterX,eax
    mov dwCenterY,0
.endif
shr edx,1
mov dwRadius,edx
add dwCenterX,edx
add dwCenterY,edx
ret
_CalcClockParam endp
;
;
;
;
_dwPara180 dw 180

_CalcX proc _dwDegree,_dwRadius
local @dwReturn

fild dwCenterX
fild _dwDegree
fldpi
fmul
fild _dwPara180
fdivp st(1),st
fsin
fild _dwRadius
fmul
fadd
fistp @dwReturn
mov eax,@dwReturn
ret

_CalcX endp
;
;
;
_CalcY proc _dwDegree,_dwRadius
local @dwReturn

fild dwCenterY
fild _dwDegree
fldpi
fmul
fild _dwPara180
fdivp st(1),st
fcos
fild _dwRadius
fmul
fsubp st(1),st
fistp @dwReturn
mov eax,@dwReturn
ret
_CalcY endp
;
;
;
_DrawDot proc _hDC,_dwDegreeInc,_dwRadius
local @dwNowDegree,@dwR
local @dwX,@dwY
mov @dwNowDegree,0
mov eax,dwRadius
sub eax,10
mov @dwR,eax
.while @dwNowDegree<=360
    finit
    ;
    ;
    ;
    invoke _CalcX,@dwNowDegree,@dwR
    mov @dwX,eax
    invoke _CalcY,@dwNowDegree,@dwR
    mov @dwY,eax

    mov eax,@dwX
    mov ebx,eax
    mov ecx,@dwY
    mov edx,ecx
    sub eax,_dwRadius
    add ebx,_dwRadius
    sub ecx,_dwRadius
    add edx,_dwRadius
    invoke Ellipse,_hDC,eax,ecx,ebx,edx

    mov eax,_dwDegreeInc
    add @dwNowDegree,eax
.endw
ret
_DrawDot endp
;
;
;
_DrawLine proc _hDC,_dwDegree,_dwRadiusAdjust
local @dwR
local @dwX1,@dwY1,@dwX2,@dwY2

mov eax,dwRadius
sub eax,_dwRadiusAdjust
mov @dwR,eax
;
;
;
invoke _CalcX,_dwDegree,@dwR
mov @dwX1,eax
invoke _CalcY,_dwDegree,@dwR
mov @dwY1,eax
add _dwDegree,180
invoke _CalcX,_dwDegree,10
mov @dwX2,eax
invoke _CalcY,_dwDegree,10
mov @dwY2,eax
invoke MoveToEx,_hDC,@dwX1,@dwY1,NULL
invoke LineTo,_hDC,@dwX2,@dwY2
ret

_DrawLine endp
;
_ShowTime proc _hWnd,_hDC
local @stTime:SYSTEMTIME

pushad
invoke GetLocalTime,addr @stTime
invoke _CalcClockParam
;
;
;
invoke GetStockObject,BLACK_BRUSH
invoke SelectObject,_hDC,eax
invoke _DrawDot,_hDC,360/12,3
invoke _DrawDot,_hDC,360/60,1
;
;
;
invoke CreatePen,PS_SOLID,1,0
invoke SelectObject,_hDC,eax
invoke DeleteObject,eax
movzx eax,@stTime.wSecond
mov ecx,360/60
mul ecx
invoke _DrawLine,_hDC,eax,15
;
invoke CreatePen,PS_SOLID,2,0
invoke SelectObject,_hDC,eax
invoke DeleteObject,eax
movzx eax,@stTime.wMinute
mov ecx,360/60
mul ecx
invoke _DrawLine,_hDC,eax,20
invoke CreatePen,PS_SOLID,3,0
invoke SelectObject,_hDC,eax
invoke DeleteObject,eax
movzx eax,@stTime.wHour
.if eax>=12
    sub eax,12
.endif
mov ecx,360/12
mul ecx
movzx ecx,@stTime.wMinute
shr ecx,1
add eax,ecx
invoke _DrawLine,_hDC,eax,30
;
invoke GetStockObject,NULL_PEN
invoke SelectObject,_hDC,eax
invoke DeleteObject,eax
popad
ret

_ShowTime endp
;
_ProcWinMain proc uses ebx edi esi hWnd,uMsg,wParam,lParam
local @stPS:PAINTSTRUCT

mov eax,uMsg
.if eax==WM_TIMER
    invoke InvalidateRect,hWnd,NULL,TRUE
.elseif eax ==WM_PAINT
    invoke BeginPaint,hWnd,addr @stPS
    invoke _ShowTime,hWnd,eax
    invoke EndPaint,hWnd,addr @stPS
.elseif eax==WM_CREATE
    invoke SetTimer,hWnd,ID_TIMER,1000,NULL
;
.elseif eax==WM_CLOSE
    invoke KillTimer,hWnd,ID_TIMER
    invoke DestroyWindow,hWinMain
    invoke PostQuitMessage,NULL
;
.else
    invoke DefWindowProc,hWnd,uMsg,wParam,lParam
    ret
.endif
;
xor eax,eax
ret
_ProcWinMain endp

_WinMain proc
local @stWndClass:WNDCLASSEX
local @stMsg:MSG

invoke GetModuleHandle,NULL
mov hInstance,eax
;
;
;
invoke RtlZeroMemory,addr @stWndClass,sizeof @stWndClass
invoke LoadIcon,hInstance,ICO_MAIN
mov @stWndClass.hIcon,eax
mov @stWndClass.hIconSm,eax
invoke LoadCursor,0,IDC_ARROW
mov @stWndClass.hCursor,eax
push hInstance
pop @stWndClass.hInstance
mov @stWndClass.cbSize,sizeof WNDCLASSEX
mov @stWndClass.style,CS_HREDRAW or CS_VREDRAW
mov @stWndClass.lpfnWndProc,offset _ProcWinMain
mov @stWndClass.hbrBackground,COLOR_WINDOW+1
mov @stWndClass.lpszClassName,offset szClassName
invoke RegisterClassEx,addr @stWndClass
;
;
;
invoke CreateWindowEx,WS_EX_CLIENTEDGE,\
    offset szClassName, offset szClassName,\
    WS_OVERLAPPEDWINDOW,\
    100,100,250,270,\
    NULL,NULL,hInstance,NULL
mov hWinMain,eax
invoke ShowWindow,hWinMain,SW_SHOWNORMAL
invoke UpdateWindow,hWinMain
;
;
;
.while TRUE
    invoke GetMessage,addr @stMsg,NULL,0,0
    .break .if eax==0
    invoke TranslateMessage,addr @stMsg
    invoke DispatchMessage,addr @stMsg
.endw
ret
_WinMain endp
;
start:
    call _WinMain
    invoke ExitProcess,NULL
;
    end start


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<title>R.integer</title>
<meta name="date" content="2017-02-06">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">

您的浏览器已禁用 JavaScript。

跳过导航链接

程序包

类

树

已过时

索引

帮助

上一个类

下一个类

框架

无框架

所有类

概要:

嵌套 |

字段 |

构造器 |

方法

详细资料:

字段 |

构造器 |

方法

com.example.xin.testapp

类 R.integer

java.lang.Object

com.example.xin.testapp.R.integer

封闭类:

R

public static final class R.integer
extends java.lang.Object

字段概要

字段

限定符和类型
字段和说明

static int
abc_config_activityDefaultDur

static int
abc_config_activityShortDur

static int
cancel_button_image_alpha

static int
status_bar_notification_info_maxnum

构造器概要

构造器

构造器和说明

integer()

方法概要

从类继承的方法 java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

字段详细资料

abc_config_activityDefaultDur

public static final int abc_config_activityDefaultDur

另请参阅:

常量字段值

abc_config_activityShortDur

public static final int abc_config_activityShortDur

另请参阅:

常量字段值

cancel_button_image_alpha

public static final int cancel_button_image_alpha

另请参阅:

常量字段值

status_bar_notification_info_maxnum

public static final int status_bar_notification_info_maxnum

另请参阅:

常量字段值

构造器详细资料

integer

public integer()

跳过导航链接

程序包

类

树

已过时

索引

帮助

上一个类

下一个类

框架

无框架

所有类

概要:

嵌套 |

字段 |

构造器 |

方法

详细资料:

字段 |

构造器 |

方法


text:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<servico xsi:schemaLocation="http://servicos.gov.br/v3/schema.../servico.xsd" xmlns="http://servicos.gov.br/v3/schema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <id>recorrer-contra-decisao-de-pedido-de-averbacao-de-contrato-no-inpi</id>
    <dbId>2865</dbId>
    <nome>Recorrer contra decisão de pedido de averbação de contrato no INPI</nome>
    <sigla></sigla>
    <descricao>Destina-se à pessoa física ou jurídica com legítimo interesse que entender que deva ser reformada ou invalidada total ou parcialmente a decisão de deferimento ou indeferimento de pedido de contrato de fornecimento de tecnologia (know-how), de serviços de assistência técnica e científica, de fatura, franquia, de licença compulsória para exploração de patente, de licença para exploração de direitos de propriedade industrial ou de cessão de direitos de propriedade industrial. O serviço consiste, basicamente, no recebimento do recurso, no seu exame e instrução técnica, na emissão de parecer sobre a matéria suscitada e na decisão da Presidência do INPI.</descricao>
    <contato></contato>
    <gratuito>false</gratuito>
    <porcentagem-manual>false</porcentagem-manual>
    <servico-digital>false</servico-digital>
    <link-servico-digital></link-servico-digital>
    <solicitantes>
        <solicitante id="3447">
            <tipo>Pessoas físicas e jurídicas</tipo>
            <requisitos></requisitos>
        </solicitante>
    </solicitantes>
    <tempo-total-estimado>
        <nao-estimado-ainda/>
        <descricao></descricao>
    </tempo-total-estimado>
    <validade-documento>
        <descricao></descricao>
    </validade-documento>
    <etapas>
        <etapa id="6670">
            <titulo>Cadastrar-se no Sistema e-INPI</titulo>
            <descricao></descricao>
            <documentos>
                <default>
                    <item id="8777">CPF</item>
                    <item id="8778">CNPJ</item>
                    <item id="8779">Comprovante de endereço</item>
                </default>
            </documentos>
            <custos>
                <default/>
            </custos>
            <canais-de-prestacao>
                <default>
                    <canal-de-prestacao id="6863" tipo="web">
                        <descricao>http://formulario.inpi.gov.br/e-inpi/termo/Termo.jsp?action=28</descricao>
                    </canal-de-prestacao>
                </default>
            </canais-de-prestacao>
        </etapa>
        <etapa id="6671">
            <titulo>Pagar Taxa</titulo>
            <descricao>Emitir e pagar a Guia de Recolhimento da União (GRU)</descricao>
            <documentos>
                <default>
                    <item id="8780">GRU</item>
                </default>
            </documentos>
            <custos>
                <default>
                    <custo id="569">
                        <descricao>Recurso (Código 416 da GRU)</descricao>
                        <moeda>R$</moeda>
                        <valor>590,00</valor>
                        <valorVariavel></valorVariavel>
                        <statusCustoVariavel>0</statusCustoVariavel>
                    </custo>
                </default>
            </custos>
            <canais-de-prestacao>
                <default>
                    <canal-de-prestacao id="6865" tipo="presencial">
                        <descricao>Rede bancária</descricao>
                    </canal-de-prestacao>
                </default>
                <caso id="792" descricao="Para gerar a GRU">
                    <canal-de-prestacao id="6864" tipo="web">
                        <descricao>https://gru.inpi.gov.br/pag/</descricao>
                    </canal-de-prestacao>
                </caso>
            </canais-de-prestacao>
        </etapa>
        <etapa id="6672">
            <titulo>Apresentar recurso</titulo>
            <descricao>Apresentar o requerimento em formulário físico ou preencher o formulário de peticionamento eletrônico no Sistema e-Contratos.</descricao>
            <documentos>
                <default>
                    <item id="8781">CPF</item>
                    <item id="8782">CNPJ</item>
                    <item id="8783">Comprovante de pagamento</item>
                </default>
            </documentos>
            <custos>
                <default/>
            </custos>
            <canais-de-prestacao>
                <default>
                    <canal-de-prestacao id="6866" tipo="web">
                        <descricao>https://gru.inpi.gov.br/peticionamentoeletronico/</descricao>
                    </canal-de-prestacao>
                    <canal-de-prestacao id="6867" tipo="presencial">
                        <descricao>Serviço de Protocolo e Expedição (SEPEX): Rua Mayrink Veiga, 9, térreo, Centro, Rio de Janeiro – RJ (CEP 20090-910).</descricao>
                    </canal-de-prestacao>
                    <canal-de-prestacao id="6868" tipo="postal">
                        <descricao>Serviço de Protocolo e Expedição (SEPEX): Rua Mayrink Veiga, 9, térreo, Centro, Rio de Janeiro – RJ (CEP 20090-910).</descricao>
                    </canal-de-prestacao>
                </default>
            </canais-de-prestacao>
        </etapa>
    </etapas>
    <orgao id="http://estruturaorganizacional.dados.gov.br/id/unidade-organizacional/382" dbId="36783">
        <nomeOrgao>Instituto Nacional da Propriedade Industrial (INPI)</nomeOrgao>
    </orgao>
    <segmentos-da-sociedade>
        <item idSegmento="1" idServicoSegmento="6545">Cidadãos</item>
        <item idSegmento="3" idServicoSegmento="6546">Empresas</item>
        <item idSegmento="4" idServicoSegmento="6547">Demais segmentos (ONGs, organizações sociais, etc)</item>
    </segmentos-da-sociedade>
    <areas-de-interesse>
        <item>Pesquisa, Ciência, Inovação e Tecnologia</item>
        <item>Pesquisa e Desenvolvimento</item>
        <item>Propriedade Industrial</item>
    </areas-de-interesse>
    <palavras-chave>
        <item id="12361">contratos</item>
        <item id="12362">recurso</item>
        <item id="12363">inpi</item>
    </palavras-chave>
</servico>


text:
package com.communote.server.web.commons.viewtool;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Base class for tools that need the request.
 *
 * @author Communote GmbH - http://www.communote.com/
 *
 */
public class RequestAwareTool {
    private HttpServletRequest request;
    private HttpServletResponse response;
    private ServletContext application;

    /**
     * @return the request
     */
    public HttpServletRequest getRequest() {
        return this.request;
    }

    /**
     * @return the response
     */
    public HttpServletResponse getResponse() {
        return response;
    }

    /**
     * @return the servlet context
     */
    public ServletContext getServletContext() {
        return application;
    }

    /**
     * Sets the current {@link HttpServletRequest}. This is required for this tool to operate and
     * will throw a NullPointerException if this is not set or is set to {@code null}.
     *
     * @param request
     *            the request
     */
    public void setRequest(HttpServletRequest request) {
        if (request == null) {
            throw new NullPointerException("request should not be null");
        }
        this.request = request;
    }

    /**
     * Sets the current {@link HttpServletResponse}. This is required for this tool to operate and
     * will throw a NullPointerException if this is not set or is set to {@code null}.
     *
     * @param response
     *            the response
     */
    public void setResponse(HttpServletResponse response) {
        if (response == null) {
            throw new NullPointerException("response should not be null");
        }
        this.response = response;
    }

    /**
     * Sets the current {@link ServletContext}. This is required for this tool to operate and will
     * throw a NullPointerException if this is not set or is set to {@code null}.
     *
     * @param application
     *            the servlet context
     */
    public void setServletContext(ServletContext application) {
        if (application == null) {
            throw new NullPointerException("servletContext should not be null");
        }
        this.application = application;
    }
}


text:
TUPLE_DEF2(entry,
           (x, float),
           (y, float),
           (name, string_t) )

void save(FILE *f, const entry_t ent)
{
  m_serial_write_t serial;
  m_serial_json_write_init(serial, f);
  entry_out_serial(serial, ent);
  m_serial_json_write_clear(serial);
}


text:
var gulp    = require('gulp'),
    path    = require('path'),
    gutil   = require('gulp-util'),
    bundle  = require('../util/bundle');

gulp.task('watch', function () {
    gulp.watch(paths.scripts, ['jshint'])
        .on('change', logChanges);

    gulp.watch(paths.appScripts, ['app'])
        .on('change', logChanges);

    return bundle.watch();
});

function logChanges(event) {
    gutil.log(
        gutil.colors.green('File ' + event.type + ': ') +
        gutil.colors.magenta(path.basename(event.path))
    );
}