Ticket #1031: 1031.diff

File 1031.diff, 24.3 KB (added by elfring, 10 years ago)

update suggestion

  • src/common/address.h

    diff --git a/src/common/address.h b/src/common/address.h
    index 9480d64..70a4906 100644
    a b  
    88 * \brief Headers for address.h
    99 **/
    1010
    11 #ifndef _TOR_ADDRESS_H
    12 #define _TOR_ADDRESS_H
     11#ifndef TOR_ADDRESS_INCLUDED
     12#define TOR_ADDRESS_INCLUDED
    1313
    1414#include "orconfig.h"
    1515#include "torint.h"
  • src/common/aes.h

    diff --git a/src/common/aes.h b/src/common/aes.h
    index f3e5796..dad8594 100644
    a b  
    55
    66/* Implements a minimal interface to counter-mode AES. */
    77
    8 #ifndef _TOR_AES_H
    9 #define _TOR_AES_H
     8#ifndef TOR_AES_INCLUDED
     9#define TOR_AES_INCLUDED
    1010
    1111/**
    1212 * \file aes.h
  • src/common/compat.h

    diff --git a/src/common/compat.h b/src/common/compat.h
    index 4d5a016..c9dbecd 100644
    a b  
    33 * Copyright (c) 2007-2009, The Tor Project, Inc. */
    44/* See LICENSE for licensing information */
    55
    6 #ifndef _TOR_COMPAT_H
    7 #define _TOR_COMPAT_H
     6#ifndef TOR_COMPAT_INCLUDED
     7#define TOR_COMPAT_INCLUDED
    88
    99#include "orconfig.h"
    1010#include "torint.h"
    extern const char TOR_TOLOWER_TABLE[]; 
    268268#define TOR_TOUPPER(c) (TOR_TOUPPER_TABLE[(uint8_t)c])
    269269
    270270#ifdef MS_WINDOWS
    271 #define _SHORT_FILE_ (tor_fix_source_file(__FILE__))
     271#define TOR_SHORT_FILE (tor_fix_source_file(__FILE__))
    272272const char *tor_fix_source_file(const char *fname);
    273273#else
    274 #define _SHORT_FILE_ (__FILE__)
     274#define TOR_SHORT_FILE (__FILE__)
    275275#define tor_fix_source_file(s) (s)
    276276#endif
    277277
  • src/common/compat_libevent.h

    diff --git a/src/common/compat_libevent.h b/src/common/compat_libevent.h
    index d2e76ce..8eb501f 100644
    a b  
    11/* Copyright (c) 2009, The Tor Project, Inc. */
    22/* See LICENSE for licensing information */
    33
    4 #ifndef _TOR_COMPAT_LIBEVENT_H
    5 #define _TOR_COMPAT_LIBEVENT_H
     4#ifndef TOR_COMPAT_LIBEVENT_INCLUDED
     5#define TOR_COMPAT_LIBEVENT_INCLUDED
    66
    77#include "orconfig.h"
    88
  • src/common/container.c

    diff --git a/src/common/container.c b/src/common/container.c
    index c649787..b99b8d3 100644
    a b digestmap_set(digestmap_t *map, const char *key, void *val) 
    829829   * the hash table that we do in the unoptimized code above.  (Each of
    830830   * HT_INSERT and HT_FIND calls HT_SET_HASH and HT_FIND_P.)
    831831   */
    832   _HT_FIND_OR_INSERT(digestmap_impl, node, digestmap_entry_hash, &(map->head),
     832  HT_FIND_OR_INSERT_(digestmap_impl, node, digestmap_entry_hash, &(map->head),
    833833         digestmap_entry_t, &search, ptr,
    834834         {
    835835            /* we found an entry. */
    digestmap_set(digestmap_t *map, const char *key, void *val) 
    843843             tor_malloc_zero(sizeof(digestmap_entry_t));
    844844           memcpy(newent->key, key, DIGEST_LEN);
    845845           newent->val = val;
    846            _HT_FOI_INSERT(node, &(map->head), &search, newent, ptr);
     846           HT_FOI_INSERT_(node, &(map->head), &search, newent, ptr);
    847847           return NULL;
    848848         });
    849849#endif
    digestmap_free(digestmap_t *map, void (*free_val)(void*)) 
    11511151void
    11521152strmap_assert_ok(const strmap_t *map)
    11531153{
    1154   tor_assert(!_strmap_impl_HT_REP_IS_BAD(&map->head));
     1154  tor_assert(!strmap_impl_HT_REP_IS_BAD_(&map->head));
    11551155}
    11561156/** Fail with an assertion error if anything has gone wrong with the internal
    11571157 * representation of <b>map</b>. */
    11581158void
    11591159digestmap_assert_ok(const digestmap_t *map)
    11601160{
    1161   tor_assert(!_digestmap_impl_HT_REP_IS_BAD(&map->head));
     1161  tor_assert(!digestmap_impl_HT_REP_IS_BAD_(&map->head));
    11621162}
    11631163
    11641164/** Return true iff <b>map</b> has no entries. */
  • src/common/container.h

    diff --git a/src/common/container.h b/src/common/container.h
    index e626552..0a2374c 100644
    a b  
    33 * Copyright (c) 2007-2009, The Tor Project, Inc. */
    44/* See LICENSE for licensing information */
    55
    6 #ifndef _TOR_CONTAINER_H
    7 #define _TOR_CONTAINER_H
     6#ifndef TOR_CONTAINER_INCLUDED
     7#define TOR_CONTAINER_INCLUDED
    88
    99#include "util.h"
    1010
  • src/common/crypto.h

    diff --git a/src/common/crypto.h b/src/common/crypto.h
    index fa6735d..0482c57 100644
    a b  
    1010 * \brief Headers for crypto.c
    1111 **/
    1212
    13 #ifndef _TOR_CRYPTO_H
    14 #define _TOR_CRYPTO_H
     13#ifndef TOR_CRYPTO_INCLUDED
     14#define TOR_CRYPTO_INCLUDED
    1515
    1616#include <stdio.h>
    1717#include "torint.h"
  • src/common/ht.h

    diff --git a/src/common/ht.h b/src/common/ht.h
    index 5187c90..f64a100 100644
    a b  
    55
    66/* Based on ideas by Christopher Clark and interfaces from Niels Provos. */
    77
    8 #ifndef _TOR_HT_H
    9 #define _TOR_HT_H
     8#ifndef TOR_HT_INCLUDED
     9#define TOR_HT_INCLUDED
    1010
    1111#define HT_HEAD(name, type)                                             \
    1212  struct name {                                                         \
     
    3535  ((head)->hth_n_entries == 0)
    3636
    3737/* Helper: alias for the bucket containing 'elm'. */
    38 #define _HT_BUCKET(head, field, elm)                                    \
     38#define HT_BUCKET_(head, field, elm)                                    \
    3939  ((head)->hth_table[elm->field.hte_hash % head->hth_table_length])
    4040
    4141/* How many elements in 'head'? */
    ht_string_hash(const char *s) 
    9898  return h;
    9999}
    100100
    101 #define _HT_SET_HASH(elm, field, hashfn)        \
     101#define HT_SET_HASH_(elm, field, hashfn)        \
    102102    (elm)->field.hte_hash = hashfn(elm)
    103103
    104104#define HT_FOREACH(x, name, head)                 \
    ht_string_hash(const char *s) 
    109109#define HT_PROTOTYPE(name, type, field, hashfn, eqfn)                   \
    110110  int name##_HT_GROW(struct name *ht, unsigned min_capacity);           \
    111111  void name##_HT_CLEAR(struct name *ht);                                \
    112   int _##name##_HT_REP_IS_BAD(const struct name *ht);                   \
     112  int name##_HT_REP_IS_BAD_(const struct name *ht);                   \
    113113  static INLINE void                                                    \
    114114  name##_HT_INIT(struct name *head) {                                   \
    115115    head->hth_table_length = 0;                                         \
    ht_string_hash(const char *s) 
    121121  /* Helper: returns a pointer to the right location in the table       \
    122122   * 'head' to find or insert the element 'elm'. */                     \
    123123  static INLINE struct type **                                          \
    124   _##name##_HT_FIND_P(struct name *head, struct type *elm)              \
     124  name##_HT_FIND_P_(struct name *head, struct type *elm)              \
    125125  {                                                                     \
    126126    struct type **p;                                                    \
    127127    if (!head->hth_table)                                               \
    128128      return NULL;                                                      \
    129     p = &_HT_BUCKET(head, field, elm);                                  \
     129    p = &HT_BUCKET_(head, field, elm);                                  \
    130130    while (*p) {                                                        \
    131131      if (eqfn(*p, elm))                                                \
    132132        return p;                                                       \
    ht_string_hash(const char *s) 
    141141  {                                                                     \
    142142    struct type **p;                                                    \
    143143    struct name *h = (struct name *) head;                              \
    144     _HT_SET_HASH(elm, field, hashfn);                                   \
    145     p = _##name##_HT_FIND_P(h, elm);                                    \
     144    HT_SET_HASH_(elm, field, hashfn);                                   \
     145    p = name##_HT_FIND_P_(h, elm);                                    \
    146146    return p ? *p : NULL;                                               \
    147147  }                                                                     \
    148148  /* Insert the element 'elm' into the table 'head'.  Do not call this  \
    ht_string_hash(const char *s) 
    154154    if (!head->hth_table || head->hth_n_entries >= head->hth_load_limit) \
    155155      name##_HT_GROW(head, head->hth_n_entries+1);                      \
    156156    ++head->hth_n_entries;                                              \
    157     _HT_SET_HASH(elm, field, hashfn);                                   \
    158     p = &_HT_BUCKET(head, field, elm);                                  \
     157    HT_SET_HASH_(elm, field, hashfn);                                   \
     158    p = &HT_BUCKET_(head, field, elm);                                  \
    159159    elm->field.hte_next = *p;                                           \
    160160    *p = elm;                                                           \
    161161  }                                                                     \
    ht_string_hash(const char *s) 
    168168    struct type **p, *r;                                                \
    169169    if (!head->hth_table || head->hth_n_entries >= head->hth_load_limit) \
    170170      name##_HT_GROW(head, head->hth_n_entries+1);                      \
    171     _HT_SET_HASH(elm, field, hashfn);                                   \
    172     p = _##name##_HT_FIND_P(head, elm);                                 \
     171    HT_SET_HASH_(elm, field, hashfn);                                   \
     172    p = name##_HT_FIND_P_(head, elm);                                 \
    173173    r = *p;                                                             \
    174174    *p = elm;                                                           \
    175175    if (r && (r!=elm)) {                                                \
    ht_string_hash(const char *s) 
    187187  name##_HT_REMOVE(struct name *head, struct type *elm)                 \
    188188  {                                                                     \
    189189    struct type **p, *r;                                                \
    190     _HT_SET_HASH(elm, field, hashfn);                                   \
    191     p = _##name##_HT_FIND_P(head,elm);                                  \
     190    HT_SET_HASH_(elm, field, hashfn);                                   \
     191    p = name##_HT_FIND_P_(head,elm);                                  \
    192192    if (!p || !*p)                                                      \
    193193      return NULL;                                                      \
    194194    r = *p;                                                             \
    ht_string_hash(const char *s) 
    368368  /* Debugging helper: return false iff the representation of 'head' is \
    369369   * internally consistent. */                                          \
    370370  int                                                                   \
    371   _##name##_HT_REP_IS_BAD(const struct name *head)                      \
     371  name##_HT_REP_IS_BAD_(const struct name *head)                      \
    372372  {                                                                     \
    373373    unsigned n, i;                                                      \
    374374    struct type *elm;                                                   \
    ht_string_hash(const char *s) 
    405405/** Implements an over-optimized "find and insert if absent" block;
    406406 * not meant for direct usage by typical code, or usage outside the critical
    407407 * path.*/
    408 #define _HT_FIND_OR_INSERT(name, field, hashfn, head, eltype, elm, var, y, n) \
     408#define HT_FIND_OR_INSERT_(name, field, hashfn, head, eltype, elm, var, y, n) \
    409409  {                                                                     \
    410     struct name *_##var##_head = head;                                  \
     410    struct name *var##_head_ = head;                                  \
    411411    eltype **var;                                                       \
    412     if (!_##var##_head->hth_table ||                                    \
    413         _##var##_head->hth_n_entries >= _##var##_head->hth_load_limit)  \
    414       name##_HT_GROW(_##var##_head, _##var##_head->hth_n_entries+1);     \
    415     _HT_SET_HASH((elm), field, hashfn);                                \
    416     var = _##name##_HT_FIND_P(_##var##_head, (elm));                    \
     412    if (!var##_head_->hth_table ||                                    \
     413        var##_head_->hth_n_entries >= var##_head_->hth_load_limit)  \
     414      name##_HT_GROW(var##_head_, var##_head_->hth_n_entries+1);     \
     415    HT_SET_HASH_((elm), field, hashfn);                                \
     416    var = name##_HT_FIND_P_(var##_head_, (elm));                    \
    417417    if (*var) {                                                         \
    418418      y;                                                                \
    419419    } else {                                                            \
    420420      n;                                                                \
    421421    }                                                                   \
    422422  }
    423 #define _HT_FOI_INSERT(field, head, elm, newent, var)       \
     423#define HT_FOI_INSERT_(field, head, elm, newent, var)       \
    424424  {                                                         \
    425425    newent->field.hte_hash = (elm)->field.hte_hash;         \
    426426    newent->field.hte_next = NULL;                          \
  • src/common/log.h

    diff --git a/src/common/log.h b/src/common/log.h
    index 6745baa..77d1835 100644
    a b  
    1010 * \brief Headers for log.c
    1111 **/
    1212
    13 #ifndef _TOR_LOG_H
     13#ifndef TOR_LOG_INCLUDED
     14#define TOR_LOG_INCLUDED
    1415
    1516#include "compat.h"
    1617
    extern const char *_log_fn_function_name; 
    201202
    202203#endif /* !GNUC */
    203204
    204 # define _TOR_LOG_H
    205205#endif
    206206
  • src/common/memarea.h

    diff --git a/src/common/memarea.h b/src/common/memarea.h
    index 04ffae7..89461db 100644
    a b  
    22/* See LICENSE for licensing information */
    33/* Tor dependencies */
    44
    5 #ifndef _TOR_MEMAREA_H
    6 #define _TOR_MEMAREA_H
     5#ifndef TOR_MEMAREA_INCLUDED
     6#define TOR_MEMAREA_INCLUDED
    77
    88typedef struct memarea_t memarea_t;
    99
  • src/common/mempool.h

    diff --git a/src/common/mempool.h b/src/common/mempool.h
    index d6813f1..aa334b6 100644
    a b  
    66 * \brief Headers for mempool.c
    77 **/
    88
    9 #ifndef _TOR_MEMPOOL_H
    10 #define _TOR_MEMPOOL_H
     9#ifndef TOR_MEMPOOL_INCLUDED
     10#define TOR_MEMPOOL_INCLUDED
    1111
    1212/** A memory pool is a context in which a large number of fixed-sized
    1313* objects can be allocated efficiently.  See mempool.c for implementation
  • src/common/test.h

    diff --git a/src/common/test.h b/src/common/test.h
    index 52a249c..908907a 100644
    a b  
    33 * Copyright (c) 2007-2009, The Tor Project, Inc. */
    44/* See LICENSE for licensing information */
    55
    6 #ifndef _TOR_TEST_H
    7 #define _TOR_TEST_H
     6#ifndef TOR_TEST_INCLUDED
     7#define TOR_TEST_INCLUDED
    88
    99/**
    1010 * \file test.h
     
    2323  STMT_BEGIN                                                    \
    2424    have_failed = 1;                                            \
    2525    printf("\nFile %s: line %d (%s): %s",                       \
    26       _SHORT_FILE_,                                             \
     26      TOR_SHORT_FILE,                                             \
    2727      __LINE__,                                                 \
    2828      PRETTY_FUNCTION,                                          \
    2929      msg);                                                     \
     
    3737  if (expr) { printf("."); fflush(stdout); } else {             \
    3838    have_failed = 1;                                            \
    3939    printf("\nFile %s: line %d (%s): assertion failed: (%s)\n", \
    40       _SHORT_FILE_,                                             \
     40      TOR_SHORT_FILE,                                             \
    4141      __LINE__,                                                 \
    4242      PRETTY_FUNCTION,                                          \
    4343      #expr);                                                   \
     
    5252    have_failed = 1;                                                    \
    5353    printf("\nFile %s: line %d (%s): Assertion failed: (%s==%s)\n"      \
    5454           "      "fmt "!="fmt"\n",                                     \
    55              _SHORT_FILE_,                                              \
     55             TOR_SHORT_FILE,                                              \
    5656             __LINE__,                                                  \
    5757             PRETTY_FUNCTION,                                           \
    5858             #expr1, #expr2,                                            \
     
    7474    have_failed = 1;                                                    \
    7575    printf("\nFile %s: line %d (%s): Assertion failed: (%s!=%s)\n"      \
    7676           "      ("fmt" == "fmt")\n",                                  \
    77            _SHORT_FILE_,                                                \
     77           TOR_SHORT_FILE,                                                \
    7878           __LINE__,                                                    \
    7979           PRETTY_FUNCTION,                                             \
    8080           #expr1, #expr2,                                              \
     
    9595    have_failed = 1;                                            \
    9696    printf("\nFile %s: line %d (%s): Assertion failed: (%s==%s)\n"\
    9797           "      (\"%s\" != \"%s\")\n",                        \
    98       _SHORT_FILE_,                                             \
     98      TOR_SHORT_FILE,                                             \
    9999      __LINE__,                                                 \
    100100      PRETTY_FUNCTION,                                          \
    101101      #expr1, #expr2,                                           \
     
    110110    have_failed = 1;                                            \
    111111    printf("\nFile %s: line %d (%s): Assertion failed: (%s!=%s)\n"\
    112112           "      (\"%s\" == \"%s\")\n",                        \
    113       _SHORT_FILE_,                                             \
     113      TOR_SHORT_FILE,                                             \
    114114      __LINE__,                                                 \
    115115      PRETTY_FUNCTION,                                          \
    116116      #expr1, #expr2,                                           \
     
    131131    base16_encode(mem2, len*2+1, _test_v2, len);                   \
    132132    printf("\nFile %s: line %d (%s): Assertion failed: (%s==%s)\n" \
    133133           "      %s != %s\n",                                     \
    134       _SHORT_FILE_,                                             \
     134      TOR_SHORT_FILE,                                             \
    135135      __LINE__,                                                 \
    136136      PRETTY_FUNCTION,                                          \
    137137      #expr1, #expr2, mem1, mem2);                              \
     
    154154      base16_encode(_mem1, _len_v2+1, _test_v1, _len_v2/2);             \
    155155      printf("\nFile %s: line %d (%s): Assertion failed: (%s==%s)\n"    \
    156156             "      %s != %s\n",                                        \
    157              _SHORT_FILE_,                                              \
     157             TOR_SHORT_FILE,                                              \
    158158             __LINE__,                                                  \
    159159             PRETTY_FUNCTION,                                           \
    160160             #expr1, _test_v2, _mem1, _test_v2);                        \
     
    173173   } else {                                                     \
    174174    have_failed = 1;                                            \
    175175    printf("\nFile %s: line %d (%s): Assertion failed: (%s!=%s)\n", \
    176       _SHORT_FILE_,                                             \
     176      TOR_SHORT_FILE,                                             \
    177177      __LINE__,                                                 \
    178178      PRETTY_FUNCTION,                                          \
    179179      #expr1, #expr2);                                          \
  • src/common/torgzip.h

    diff --git a/src/common/torgzip.h b/src/common/torgzip.h
    index d643228..bf5ed45 100644
    a b  
    88 * \brief Headers for torgzip.h
    99 **/
    1010
    11 #ifndef _TOR_TORGZIP_H
    12 #define _TOR_TORGZIP_H
     11#ifndef TOR_TORGZIP_INCLUDED
     12#define TOR_TORGZIP_INCLUDED
    1313
    1414/** Enumeration of what kind of compression to use.  Only ZLIB_METHOD is
    1515 * guaranteed to be supported by the compress/uncompress functions here;
  • src/common/torint.h

    diff --git a/src/common/torint.h b/src/common/torint.h
    index 1f74211..b4ccfcd 100644
    a b  
    88 * \brief Header file to define uint32_t and friends
    99 **/
    1010
    11 #ifndef _TOR_TORINT_H
    12 #define _TOR_TORINT_H
     11#ifndef TOR_TORINT_INCLUDED
     12#define TOR_TORINT_INCLUDED
    1313
    1414#include "orconfig.h"
    1515
  • src/common/tortls.h

    diff --git a/src/common/tortls.h b/src/common/tortls.h
    index 44e3b49..7f5baf4 100644
    a b  
    33 * Copyright (c) 2007-2009, The Tor Project, Inc. */
    44/* See LICENSE for licensing information */
    55
    6 #ifndef _TOR_TORTLS_H
    7 #define _TOR_TORTLS_H
     6#ifndef TOR_TORTLS_INCLUDED
     7#define TOR_TORTLS_INCLUDED
    88
    99/**
    1010 * \file tortls.h
  • src/common/util.h

    diff --git a/src/common/util.h b/src/common/util.h
    index 18033f3..24a16cc 100644
    a b  
    88 * \brief Headers for util.c
    99 **/
    1010
    11 #ifndef _TOR_UTIL_H
    12 #define _TOR_UTIL_H
     11#ifndef TOR_UTIL_INCLUDED
     12#define TOR_UTIL_INCLUDED
    1313
    1414#include "orconfig.h"
    1515#include "torint.h"
     
    4444#define tor_assert(expr) STMT_BEGIN                                     \
    4545    if (PREDICT_UNLIKELY(!(expr))) {                                    \
    4646      log(LOG_ERR, LD_BUG, "%s:%d: %s: Assertion %s failed; aborting.", \
    47           _SHORT_FILE_, __LINE__, __func__, #expr);                     \
     47          TOR_SHORT_FILE, __LINE__, __func__, #expr);                     \
    4848      fprintf(stderr,"%s:%d %s: Assertion %s failed; aborting.\n",      \
    49               _SHORT_FILE_, __LINE__, __func__, #expr);                 \
     49              TOR_SHORT_FILE, __LINE__, __func__, #expr);                 \
    5050      abort();                                                          \
    5151    } STMT_END
    5252
     
    5757 * to calls. */
    5858#ifdef USE_DMALLOC
    5959#define DMALLOC_PARAMS , const char *file, const int line
    60 #define DMALLOC_ARGS , _SHORT_FILE_, __LINE__
     60#define DMALLOC_ARGS , TOR_SHORT_FILE, __LINE__
    6161#else
    6262#define DMALLOC_PARAMS
    6363#define DMALLOC_ARGS
    extern int dmalloc_free(const char *file, const int line, void *pnt, 
    8484                        const int func_id);
    8585#define tor_free(p) STMT_BEGIN \
    8686    if (PREDICT_LIKELY((p)!=NULL)) {                \
    87       dmalloc_free(_SHORT_FILE_, __LINE__, (p), 0); \
     87      dmalloc_free(TOR_SHORT_FILE, __LINE__, (p), 0); \
    8888      (p)=NULL;                                     \
    8989    }                                               \
    9090  STMT_END
  • src/or/eventdns.h

    diff --git a/src/or/eventdns.h b/src/or/eventdns.h
    index 734bacf..f2d6e4d 100644
    a b  
    209209 * with the next probe.
    210210 */
    211211
    212 #ifndef _TOR_EVENTDNS_H
    213 #define _TOR_EVENTDNS_H
     212#ifndef TOR_EVENTDNS_INCLUDED
     213#define TOR_EVENTDNS_INCLUDED
    214214
    215215/* Error codes 0-5 are as described in RFC 1035. */
    216216#define DNS_ERR_NONE 0
  • src/or/or.h

    diff --git a/src/or/or.h b/src/or/or.h
    index f298d53..de01be6 100644
    a b  
    99 * \brief Master header file for Tor-specific functionality.
    1010 **/
    1111
    12 #ifndef _TOR_OR_H
    13 #define _TOR_OR_H
     12#ifndef TOR_OR_INCLUDED
     13#define TOR_OR_INCLUDED
    1414
    1515#include "orconfig.h"
    1616
    void circuit_get_all_pending_on_or_conn(smartlist_t *out, 
    28182818int circuit_count_pending_on_or_conn(or_connection_t *or_conn);
    28192819
    28202820#define circuit_mark_for_close(c, reason)                               \
    2821   _circuit_mark_for_close((c), (reason), __LINE__, _SHORT_FILE_)
     2821  _circuit_mark_for_close((c), (reason), __LINE__, TOR_SHORT_FILE)
    28222822
    28232823void assert_cpath_layer_ok(const crypt_path_t *cp);
    28242824void assert_circuit_ok(const circuit_t *c);
    void connection_close_immediate(connection_t *conn); 
    29582958void _connection_mark_for_close(connection_t *conn,int line, const char *file);
    29592959
    29602960#define connection_mark_for_close(c) \
    2961   _connection_mark_for_close((c), __LINE__, _SHORT_FILE_)
     2961  _connection_mark_for_close((c), __LINE__, TOR_SHORT_FILE)
    29622962
    29632963void connection_expire_held_open(void);
    29642964
    void remove_file_if_very_old(const char *fname, time_t now); 
    30243024/********************************* connection_edge.c *************************/
    30253025
    30263026#define connection_mark_unattached_ap(conn, endreason) \
    3027   _connection_mark_unattached_ap((conn), (endreason), __LINE__, _SHORT_FILE_)
     3027  _connection_mark_unattached_ap((conn), (endreason), __LINE__, TOR_SHORT_FILE)
    30283028
    30293029void _connection_mark_unattached_ap(edge_connection_t *conn, int endreason,
    30303030                                    int line, const char *file);