repo_id stringlengths 6 101 | size int64 367 5.14M | file_path stringlengths 2 269 | content stringlengths 367 5.14M |
|---|---|---|---|
281677160/openwrt-package | 1,611 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/ds/stream.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_DS_STREAM_H
#define LIBCORK_DS_STREAM_H
#include <stdio.h>
#include <libcork/core/api.h>
#include <libcork/core/types.h>
struct cork_stream_consumer {
int
(*data)(struct cork_stream_consumer *consumer,
const void *buf, size_t size, bool is_first_chunk);
int
(*eof)(struct cork_stream_consumer *consumer);
void
(*free)(struct cork_stream_consumer *consumer);
};
#define cork_stream_consumer_data(consumer, buf, size, is_first) \
((consumer)->data((consumer), (buf), (size), (is_first)))
#define cork_stream_consumer_eof(consumer) \
((consumer)->eof((consumer)))
#define cork_stream_consumer_free(consumer) \
((consumer)->free((consumer)))
CORK_API int
cork_consume_fd(struct cork_stream_consumer *consumer, int fd);
CORK_API int
cork_consume_file(struct cork_stream_consumer *consumer, FILE *fp);
CORK_API int
cork_consume_file_from_path(struct cork_stream_consumer *consumer,
const char *path, int flags);
CORK_API struct cork_stream_consumer *
cork_fd_consumer_new(int fd);
CORK_API struct cork_stream_consumer *
cork_file_consumer_new(FILE *fp);
CORK_API struct cork_stream_consumer *
cork_file_from_path_consumer_new(const char *path, int flags);
#endif /* LIBCORK_DS_STREAM_H */
|
281677160/openwrt-package | 2,007 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/ds/bitset.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2013, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_DS_BITS_H
#define LIBCORK_DS_BITS_H
#include <libcork/core/api.h>
#include <libcork/core/types.h>
/*-----------------------------------------------------------------------
* Bit sets
*/
struct cork_bitset {
uint8_t *bits;
size_t bit_count;
size_t byte_count;
};
CORK_API struct cork_bitset *
cork_bitset_new(size_t bit_count);
CORK_API void
cork_bitset_init(struct cork_bitset *set, size_t bit_count);
CORK_API void
cork_bitset_free(struct cork_bitset *set);
CORK_API void
cork_bitset_done(struct cork_bitset *set);
CORK_API void
cork_bitset_clear(struct cork_bitset *set);
/* Extract the byte that contains a particular bit in an array. */
#define cork_bitset_byte_for_bit(set, i) \
((set)->bits[(i) / 8])
/* Create a bit mask that extracts a particular bit from the byte that it lives
* in. */
#define cork_bitset_pos_mask_for_bit(i) \
(0x80 >> ((i) % 8))
/* Create a bit mask that extracts everything except for a particular bit from
* the byte that it lives in. */
#define cork_bitset_neg_mask_for_bit(i) \
(~cork_bitset_pos_mask_for_bit(i))
/* Return whether a particular bit is set in a byte array. Bits are numbered
* from 0, in a big-endian order. */
#define cork_bitset_get(set, i) \
((cork_bitset_byte_for_bit(set, i) & cork_bitset_pos_mask_for_bit(i)) != 0)
/* Set (or unset) a particular bit is set in a byte array. Bits are numbered
* from 0, in a big-endian order. */
#define cork_bitset_set(set, i, val) \
(cork_bitset_byte_for_bit(set, i) = \
(cork_bitset_byte_for_bit(set, i) & cork_bitset_neg_mask_for_bit(i)) \
| ((val)? cork_bitset_pos_mask_for_bit(i): 0))
#endif /* LIBCORK_DS_BITS_H */
|
281677160/openwrt-package | 1,600 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/ds/ring-buffer.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_DS_RING_BUFFER_H
#define LIBCORK_DS_RING_BUFFER_H
#include <libcork/core/api.h>
#include <libcork/core/types.h>
struct cork_ring_buffer {
/* The elements of the ring buffer */
void **elements;
/* The number of elements that can be stored in this ring
* buffer. */
size_t allocated_size;
/* The actual number of elements currently in the ring buffer. */
size_t size;
/* The index of the next element to read from the buffer */
size_t read_index;
/* The index of the next element to write into the buffer */
size_t write_index;
};
CORK_API int
cork_ring_buffer_init(struct cork_ring_buffer *buf, size_t size);
CORK_API struct cork_ring_buffer *
cork_ring_buffer_new(size_t size);
CORK_API void
cork_ring_buffer_done(struct cork_ring_buffer *buf);
CORK_API void
cork_ring_buffer_free(struct cork_ring_buffer *buf);
#define cork_ring_buffer_is_empty(buf) ((buf)->size == 0)
#define cork_ring_buffer_is_full(buf) ((buf)->size == (buf)->allocated_size)
CORK_API int
cork_ring_buffer_add(struct cork_ring_buffer *buf, void *element);
CORK_API void *
cork_ring_buffer_pop(struct cork_ring_buffer *buf);
CORK_API void *
cork_ring_buffer_peek(struct cork_ring_buffer *buf);
#endif /* LIBCORK_DS_RING_BUFFER_H */
|
281677160/openwrt-package | 2,095 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/ds/managed-buffer.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_DS_MANAGED_BUFFER_H
#define LIBCORK_DS_MANAGED_BUFFER_H
#include <libcork/core/api.h>
#include <libcork/core/types.h>
#include <libcork/ds/slice.h>
/*-----------------------------------------------------------------------
* Managed buffers
*/
struct cork_managed_buffer;
struct cork_managed_buffer_iface {
/* Free the contents of a managed buffer, and the managed buffer
* object itself. */
void
(*free)(struct cork_managed_buffer *buf);
};
struct cork_managed_buffer {
/* The buffer that this instance manages */
const void *buf;
/* The size of buf */
size_t size;
/* A reference count for the buffer. If this drops to 0, the buffer
* will be finalized. */
volatile int ref_count;
/* The managed buffer implementation for this instance. */
struct cork_managed_buffer_iface *iface;
};
CORK_API struct cork_managed_buffer *
cork_managed_buffer_new_copy(const void *buf, size_t size);
typedef void
(*cork_managed_buffer_freer)(void *buf, size_t size);
CORK_API struct cork_managed_buffer *
cork_managed_buffer_new(const void *buf, size_t size,
cork_managed_buffer_freer free);
CORK_API struct cork_managed_buffer *
cork_managed_buffer_ref(struct cork_managed_buffer *buf);
CORK_API void
cork_managed_buffer_unref(struct cork_managed_buffer *buf);
CORK_API int
cork_managed_buffer_slice(struct cork_slice *dest,
struct cork_managed_buffer *buffer,
size_t offset, size_t length);
CORK_API int
cork_managed_buffer_slice_offset(struct cork_slice *dest,
struct cork_managed_buffer *buffer,
size_t offset);
#endif /* LIBCORK_DS_MANAGED_BUFFER_H */
|
281677160/openwrt-package | 4,795 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/ds/slice.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_DS_SLICE_H
#define LIBCORK_DS_SLICE_H
#include <libcork/core/api.h>
#include <libcork/core/types.h>
/*-----------------------------------------------------------------------
* Error handling
*/
/* hash of "libcork/ds/slice.h" */
#define CORK_SLICE_ERROR 0x960ca750
enum cork_slice_error {
/* Trying to slice a nonexistent subset of a buffer */
CORK_SLICE_INVALID_SLICE
};
/*-----------------------------------------------------------------------
* Slices
*/
struct cork_slice;
struct cork_slice_iface {
/* Free the slice. Can be NULL if you don't need to free any
* underlying buffer. */
void
(*free)(struct cork_slice *self);
/* Create a copy of a slice. You can assume that offset and length
* refer to a valid subset of the buffer. */
int
(*copy)(struct cork_slice *dest, const struct cork_slice *self,
size_t offset, size_t length);
/* Create a “light” copy of a slice. A light copy is not allowed to exist
* longer than the slice that it was copied from, which can sometimes let
* you perform less work to produce the copy. You can assume that offset
* and length refer to a valid subset of the buffer. */
int
(*light_copy)(struct cork_slice *dest, const struct cork_slice *self,
size_t offset, size_t length);
/* Update the current slice to point at a different subset. You can
* assume that offset and length refer to a valid subset of the
* buffer. Can be NULL if you don't need to do anything special to
* the underlying buffer; in this case, we'll update the slice's buf
* and size fields for you. */
int
(*slice)(struct cork_slice *self, size_t offset, size_t length);
};
struct cork_slice {
/* The beginning of the sliced portion of the buffer. */
const void *buf;
/* The length of the sliced portion of the buffer. */
size_t size;
/* The slice implementation of the underlying buffer. */
struct cork_slice_iface *iface;
/* An opaque pointer used by the slice implementation to refer to
* the underlying buffer. */
void *user_data;
};
CORK_API void
cork_slice_clear(struct cork_slice *slice);
#define cork_slice_is_empty(slice) ((slice)->buf == NULL)
CORK_API int
cork_slice_copy(struct cork_slice *dest, const struct cork_slice *slice,
size_t offset, size_t length);
#define cork_slice_copy_fast(dest, slice, offset, length) \
((slice)->iface->copy((dest), (slice), (offset), (length)))
CORK_API int
cork_slice_copy_offset(struct cork_slice *dest, const struct cork_slice *slice,
size_t offset);
#define cork_slice_copy_offset_fast(dest, slice, offset) \
((slice)->iface->copy \
((dest), (slice), (offset), (slice)->size - (offset)))
CORK_API int
cork_slice_light_copy(struct cork_slice *dest, const struct cork_slice *slice,
size_t offset, size_t length);
#define cork_slice_light_copy_fast(dest, slice, offset, length) \
((slice)->iface->light_copy((dest), (slice), (offset), (length)))
CORK_API int
cork_slice_light_copy_offset(struct cork_slice *dest,
const struct cork_slice *slice, size_t offset);
#define cork_slice_light_copy_offset_fast(dest, slice, offset) \
((slice)->iface->light_copy \
((dest), (slice), (offset), (slice)->size - (offset)))
CORK_API int
cork_slice_slice(struct cork_slice *slice, size_t offset, size_t length);
#define cork_slice_slice_fast(_slice, offset, length) \
((_slice)->iface->slice == NULL? \
((_slice)->buf += (offset), (_slice)->size = (length), 0): \
((_slice)->iface->slice((_slice), (offset), (length))))
CORK_API int
cork_slice_slice_offset(struct cork_slice *slice, size_t offset);
#define cork_slice_slice_offset_fast(_slice, offset) \
((_slice)->iface->slice == NULL? \
((_slice)->buf += (offset), (_slice)->size -= (offset), 0): \
((_slice)->iface->slice \
((_slice), (offset), (_slice)->size - (offset))))
CORK_API void
cork_slice_finish(struct cork_slice *slice);
CORK_API bool
cork_slice_equal(const struct cork_slice *slice1,
const struct cork_slice *slice2);
CORK_API void
cork_slice_init_static(struct cork_slice *dest, const void *buf, size_t size);
CORK_API void
cork_slice_init_copy_once(struct cork_slice *dest, const void *buf,
size_t size);
#endif /* LIBCORK_DS_SLICE_H */
|
281677160/openwrt-package | 4,887 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/ds/hash-table.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011-2013, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_DS_HASH_TABLE_H
#define LIBCORK_DS_HASH_TABLE_H
#include <libcork/core/api.h>
#include <libcork/core/callbacks.h>
#include <libcork/core/hash.h>
#include <libcork/core/mempool.h>
#include <libcork/core/types.h>
#include <libcork/ds/dllist.h>
/*-----------------------------------------------------------------------
* Hash tables
*/
struct cork_hash_table_entry {
cork_hash hash;
void *key;
void *value;
};
struct cork_hash_table;
CORK_API struct cork_hash_table *
cork_hash_table_new(size_t initial_size, unsigned int flags);
CORK_API void
cork_hash_table_free(struct cork_hash_table *table);
CORK_API void
cork_hash_table_set_user_data(struct cork_hash_table *table,
void *user_data, cork_free_f free_user_data);
CORK_API void
cork_hash_table_set_equals(struct cork_hash_table *table, cork_equals_f equals);
CORK_API void
cork_hash_table_set_free_key(struct cork_hash_table *table, cork_free_f free);
CORK_API void
cork_hash_table_set_free_value(struct cork_hash_table *table, cork_free_f free);
CORK_API void
cork_hash_table_set_hash(struct cork_hash_table *table, cork_hash_f hash);
CORK_API void
cork_hash_table_clear(struct cork_hash_table *table);
CORK_API void
cork_hash_table_ensure_size(struct cork_hash_table *table,
size_t desired_count);
CORK_API size_t
cork_hash_table_size(const struct cork_hash_table *table);
CORK_API void *
cork_hash_table_get(const struct cork_hash_table *table, const void *key);
CORK_API void *
cork_hash_table_get_hash(const struct cork_hash_table *table,
cork_hash hash, const void *key);
CORK_API struct cork_hash_table_entry *
cork_hash_table_get_entry(const struct cork_hash_table *table,
const void *key);
CORK_API struct cork_hash_table_entry *
cork_hash_table_get_entry_hash(const struct cork_hash_table *table,
cork_hash hash, const void *key);
CORK_API struct cork_hash_table_entry *
cork_hash_table_get_or_create(struct cork_hash_table *table,
void *key, bool *is_new);
CORK_API struct cork_hash_table_entry *
cork_hash_table_get_or_create_hash(struct cork_hash_table *table,
cork_hash hash, void *key, bool *is_new);
CORK_API void
cork_hash_table_put(struct cork_hash_table *table,
void *key, void *value,
bool *is_new, void **old_key, void **old_value);
CORK_API void
cork_hash_table_put_hash(struct cork_hash_table *table,
cork_hash hash, void *key, void *value,
bool *is_new, void **old_key, void **old_value);
CORK_API void
cork_hash_table_delete_entry(struct cork_hash_table *table,
struct cork_hash_table_entry *entry);
CORK_API bool
cork_hash_table_delete(struct cork_hash_table *table, const void *key,
void **deleted_key, void **deleted_value);
CORK_API bool
cork_hash_table_delete_hash(struct cork_hash_table *table,
cork_hash hash, const void *key,
void **deleted_key, void **deleted_value);
enum cork_hash_table_map_result {
/* Abort the current @ref cork_hash_table_map operation. */
CORK_HASH_TABLE_MAP_ABORT = 0,
/* Continue on to the next entry in the hash table. */
CORK_HASH_TABLE_MAP_CONTINUE = 1,
/* Delete the entry that was just processed, and then continue on to
* the next entry in the hash table. */
CORK_HASH_TABLE_MAP_DELETE = 2
};
typedef enum cork_hash_table_map_result
(*cork_hash_table_map_f)(void *user_data, struct cork_hash_table_entry *entry);
CORK_API void
cork_hash_table_map(struct cork_hash_table *table, void *user_data,
cork_hash_table_map_f mapper);
struct cork_hash_table_iterator {
struct cork_hash_table *table;
void *priv;
};
CORK_API void
cork_hash_table_iterator_init(struct cork_hash_table *table,
struct cork_hash_table_iterator *iterator);
CORK_API struct cork_hash_table_entry *
cork_hash_table_iterator_next(struct cork_hash_table_iterator *iterator);
/*-----------------------------------------------------------------------
* Built-in key types
*/
CORK_API struct cork_hash_table *
cork_string_hash_table_new(size_t initial_size, unsigned int flags);
CORK_API struct cork_hash_table *
cork_pointer_hash_table_new(size_t initial_size, unsigned int flags);
#endif /* LIBCORK_DS_HASH_TABLE_H */
|
281677160/openwrt-package | 4,554 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/ds/dllist.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011-2014, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_DS_DLLIST_H
#define LIBCORK_DS_DLLIST_H
#include <libcork/core/api.h>
#include <libcork/core/types.h>
struct cork_dllist_item {
/* A pointer to the next element in the list. */
struct cork_dllist_item *next;
/* A pointer to the previous element in the list. */
struct cork_dllist_item *prev;
};
struct cork_dllist {
/* The sentinel element for this list. */
struct cork_dllist_item head;
};
#define CORK_DLLIST_INIT(list) { { &(list).head, &(list).head } }
#define cork_dllist_init(list) \
do { \
(list)->head.next = &(list)->head; \
(list)->head.prev = &(list)->head; \
} while (0)
/* DEPRECATED! Use cork_dllist_foreach or cork_dllist_visit instead. */
typedef void
(*cork_dllist_map_func)(struct cork_dllist_item *element, void *user_data);
CORK_API void
cork_dllist_map(struct cork_dllist *list,
cork_dllist_map_func func, void *user_data);
typedef int
cork_dllist_visit_f(void *ud, struct cork_dllist_item *element);
CORK_API int
cork_dllist_visit(struct cork_dllist *list, void *ud,
cork_dllist_visit_f *visit);
#define cork_dllist_foreach_void(list, curr, _next) \
for ((curr) = cork_dllist_start((list)), (_next) = (curr)->next; \
!cork_dllist_is_end((list), (curr)); \
(curr) = (_next), (_next) = (curr)->next)
#define cork_dllist_foreach(list, curr, _next, etype, element, item_field) \
for ((curr) = cork_dllist_start((list)), (_next) = (curr)->next, \
(element) = cork_container_of((curr), etype, item_field); \
!cork_dllist_is_end((list), (curr)); \
(curr) = (_next), (_next) = (curr)->next, \
(element) = cork_container_of((curr), etype, item_field))
CORK_API size_t
cork_dllist_size(const struct cork_dllist *list);
#define cork_dllist_add_after(pred, element) \
do { \
(element)->prev = (pred); \
(element)->next = (pred)->next; \
(pred)->next->prev = (element); \
(pred)->next = (element); \
} while (0)
#define cork_dllist_add_before(succ, element) \
do { \
(element)->next = (succ); \
(element)->prev = (succ)->prev; \
(succ)->prev->next = (element); \
(succ)->prev = (element); \
} while (0)
#define cork_dllist_add_to_head(list, element) \
cork_dllist_add_after(&(list)->head, (element))
#define cork_dllist_add_to_tail(list, element) \
cork_dllist_add_before(&(list)->head, (element))
#define cork_dllist_add cork_dllist_add_to_tail
#define cork_dllist_add_list_to_head(dest, src) \
do { \
struct cork_dllist_item *dest_start = cork_dllist_start(dest); \
struct cork_dllist_item *src_start = cork_dllist_start(src); \
dest_start->prev = &(src)->head; \
src_start->prev = &(dest)->head; \
(src)->head.next = dest_start; \
(dest)->head.next = src_start; \
cork_dllist_remove(&(src)->head); \
cork_dllist_init(src); \
} while (0)
#define cork_dllist_add_list_to_tail(dest, src) \
do { \
struct cork_dllist_item *dest_end = cork_dllist_end(dest); \
struct cork_dllist_item *src_end = cork_dllist_end(src); \
dest_end->next = &(src)->head; \
src_end->next = &(dest)->head; \
(src)->head.prev = dest_end; \
(dest)->head.prev = src_end; \
cork_dllist_remove(&(src)->head); \
cork_dllist_init(src); \
} while (0)
#define cork_dllist_remove(element) \
do { \
(element)->prev->next = (element)->next; \
(element)->next->prev = (element)->prev; \
} while (0)
#define cork_dllist_is_empty(list) \
(cork_dllist_is_end((list), cork_dllist_start((list))))
#define cork_dllist_head(list) \
(((list)->head.next == &(list)->head)? NULL: (list)->head.next)
#define cork_dllist_tail(list) \
(((list)->head.prev == &(list)->head)? NULL: (list)->head.prev)
#define cork_dllist_start(list) \
((list)->head.next)
#define cork_dllist_end(list) \
((list)->head.prev)
#define cork_dllist_is_start(list, element) \
((element) == &(list)->head)
#define cork_dllist_is_end(list, element) \
((element) == &(list)->head)
#endif /* LIBCORK_DS_DLLIST_H */
|
281677160/openwrt-package | 1,382 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/cli/commands.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2012, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_COMMANDS_H
#define LIBCORK_COMMANDS_H
#include <libcork/core/api.h>
typedef void
(*cork_leaf_command_run)(int argc, char **argv);
typedef int
(*cork_option_parser)(int argc, char **argv);
enum cork_command_type {
CORK_COMMAND_SET,
CORK_LEAF_COMMAND
};
struct cork_command {
enum cork_command_type type;
const char *name;
const char *short_desc;
const char *usage_suffix;
const char *full_help;
int
(*parse_options)(int argc, char **argv);
struct cork_command **set;
cork_leaf_command_run run;
};
#define cork_command_set(name, sd, parse_options, set) \
{ \
CORK_COMMAND_SET, name, sd, NULL, NULL, \
parse_options, set, NULL \
}
#define cork_leaf_command(name, sd, us, fh, parse_options, run) \
{ \
CORK_LEAF_COMMAND, name, sd, us, fh, \
parse_options, NULL, run \
}
CORK_API void
cork_command_show_help(struct cork_command *command, const char *message);
CORK_API int
cork_command_main(struct cork_command *root, int argc, char **argv);
#endif /* LIBCORK_COMMANDS_H */
|
281677160/openwrt-package | 6,119 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/threads/basics.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2012-2014, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_THREADS_BASICS_H
#define LIBCORK_THREADS_BASICS_H
#include <assert.h>
#include <libcork/core/api.h>
#include <libcork/core/attributes.h>
#include <libcork/core/callbacks.h>
#include <libcork/threads/atomics.h>
/*-----------------------------------------------------------------------
* Thread IDs
*/
typedef unsigned int cork_thread_id;
#define CORK_THREAD_NONE ((cork_thread_id) 0)
/* Returns a valid ID for any thread — even the main thread and threads that
* aren't created by libcork. */
CORK_API cork_thread_id
cork_current_thread_get_id(void);
/*-----------------------------------------------------------------------
* Threads
*/
struct cork_thread;
/* Returns NULL for the main thread, and for any thread not created via
* cork_thread_new/cork_thread_start. */
CORK_API struct cork_thread *
cork_current_thread_get(void);
CORK_API struct cork_thread *
cork_thread_new(const char *name,
void *user_data, cork_free_f free_user_data,
cork_run_f run);
/* Thread must not have been started yet. */
CORK_API void
cork_thread_free(struct cork_thread *thread);
CORK_API const char *
cork_thread_get_name(struct cork_thread *thread);
CORK_API cork_thread_id
cork_thread_get_id(struct cork_thread *thread);
/* Can only be called once per thread. Thread will automatically be freed when
* its done. */
CORK_API int
cork_thread_start(struct cork_thread *thread);
/* Can only be called once per thread; must be called after cork_thread_start. */
CORK_API int
cork_thread_join(struct cork_thread *thread);
/*-----------------------------------------------------------------------
* Executing something once
*/
#if CORK_CONFIG_HAVE_GCC_ASM && (CORK_CONFIG_ARCH_X86 || CORK_CONFIG_ARCH_X64)
#define cork_pause() \
do { \
__asm__ __volatile__ ("pause"); \
} while (0)
#else
#define cork_pause() do { /* do nothing */ } while (0)
#endif
#define cork_once_barrier(name) \
static struct { \
volatile int barrier; \
cork_thread_id initializing_thread; \
} name##__once;
#define cork_once(name, call) \
do { \
if (CORK_LIKELY(name##__once.barrier == 2)) { \
/* already initialized */ \
} else { \
/* Try to claim the ability to perform the initialization */ \
int prior_state = cork_int_cas(&name##__once.barrier, 0, 1); \
if (CORK_LIKELY(prior_state == 0)) { \
CORK_ATTR_UNUSED int result; \
/* we get to initialize */ \
call; \
result = cork_int_cas(&name##__once.barrier, 1, 2); \
assert(result == 1); \
} else { \
/* someone else is initializing, spin/wait until done */ \
while (name##__once.barrier != 2) { cork_pause(); } \
} \
} \
} while (0)
#define cork_once_recursive(name, call) \
do { \
if (CORK_LIKELY(name##__once.barrier == 2)) { \
/* already initialized */ \
} else { \
/* Try to claim the ability to perform the initialization */ \
int prior_state = cork_int_cas(&name##__once.barrier, 0, 1); \
if (CORK_LIKELY(prior_state == 0)) { \
CORK_ATTR_UNUSED int result; \
/* we get to initialize */ \
name##__once.initializing_thread = \
cork_current_thread_get_id(); \
call; \
result = cork_int_cas(&name##__once.barrier, 1, 2); \
assert(result == 1); \
} else { \
/* someone else is initializing, is it us? */ \
if (name##__once.initializing_thread == \
cork_current_thread_get_id()) { \
/* yep, fall through to let our recursion continue */ \
} else { \
/* nope; wait for the initialization to finish */ \
while (name##__once.barrier != 2) { cork_pause(); } \
} \
} \
} \
} while (0)
/*-----------------------------------------------------------------------
* Thread-local storage
*/
/* Prefer, in order:
*
* 1) __thread storage class
* 2) pthread_key_t
*/
#if CORK_CONFIG_HAVE_THREAD_STORAGE_CLASS
#define cork_tls(TYPE, NAME) \
static __thread TYPE NAME##__tls; \
\
static TYPE * \
NAME##_get(void) \
{ \
return &NAME##__tls; \
}
#define cork_tls_with_alloc(TYPE, NAME, allocate, deallocate) \
cork_tls(TYPE, NAME)
#elif CORK_HAVE_PTHREADS
#include <stdlib.h>
#include <pthread.h>
#include <libcork/core/allocator.h>
#define cork_tls_with_alloc(TYPE, NAME, allocate, deallocate) \
static pthread_key_t NAME##__tls_key; \
cork_once_barrier(NAME##__tls_barrier); \
\
static void \
NAME##__tls_destroy(void *self) \
{ \
deallocate(self); \
} \
\
static void \
NAME##__create_key(void) \
{ \
CORK_ATTR_UNUSED int rc; \
rc = pthread_key_create(&NAME##__tls_key, &NAME##__tls_destroy); \
assert(rc == 0); \
} \
\
static TYPE * \
NAME##_get(void) \
{ \
TYPE *self; \
cork_once(NAME##__tls_barrier, NAME##__create_key()); \
self = pthread_getspecific(NAME##__tls_key); \
if (CORK_UNLIKELY(self == NULL)) { \
self = allocate(); \
pthread_setspecific(NAME##__tls_key, self); \
} \
return self; \
}
#define cork_tls(TYPE, NAME) \
\
static TYPE * \
NAME##__tls_allocate(void) \
{ \
return cork_calloc(1, sizeof(TYPE)); \
} \
\
static void \
NAME##__tls_deallocate(void *vself) \
{ \
cork_cfree(vself, 1, sizeof(TYPE)); \
} \
\
cork_tls_with_alloc(TYPE, NAME, NAME##__tls_allocate, NAME##__tls_deallocate);
#else
#error "No thread-local storage implementation!"
#endif
#endif /* LIBCORK_THREADS_BASICS_H */
|
281677160/openwrt-package | 1,776 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/threads/atomics.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2012, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_THREADS_ATOMICS_H
#define LIBCORK_THREADS_ATOMICS_H
#include <libcork/config.h>
#include <libcork/core/types.h>
/*-----------------------------------------------------------------------
* GCC intrinsics
*/
/* Ideally we can use GCC's intrinsics to define everything */
#if defined(CORK_CONFIG_HAVE_GCC_ATOMICS)
#define cork_int_atomic_add __sync_add_and_fetch
#define cork_uint_atomic_add __sync_add_and_fetch
#define cork_size_atomic_add __sync_add_and_fetch
#define cork_int_atomic_pre_add __sync_fetch_and_add
#define cork_uint_atomic_pre_add __sync_fetch_and_add
#define cork_size_atomic_pre_add __sync_fetch_and_add
#define cork_int_atomic_sub __sync_sub_and_fetch
#define cork_uint_atomic_sub __sync_sub_and_fetch
#define cork_size_atomic_sub __sync_sub_and_fetch
#define cork_int_atomic_pre_sub __sync_fetch_and_sub
#define cork_uint_atomic_pre_sub __sync_fetch_and_sub
#define cork_size_atomic_pre_sub __sync_fetch_and_sub
#define cork_int_cas __sync_val_compare_and_swap
#define cork_uint_cas __sync_val_compare_and_swap
#define cork_size_cas __sync_val_compare_and_swap
#define cork_ptr_cas __sync_val_compare_and_swap
/*-----------------------------------------------------------------------
* End of atomic implementations
*/
#else
#error "No atomics implementation!"
#endif
#endif /* LIBCORK_THREADS_ATOMICS_H */
|
281677160/openwrt-package | 1,063 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/config/arch.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2012-2013, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CONFIG_ARCH_H
#define LIBCORK_CONFIG_ARCH_H
/*-----------------------------------------------------------------------
* Platform
*/
#if defined(__i386__) || defined(_M_IX86)
#define CORK_CONFIG_ARCH_X86 1
#else
#define CORK_CONFIG_ARCH_X86 0
#endif
#if defined(__x86_64__) || defined(_M_X64)
#define CORK_CONFIG_ARCH_X64 1
#else
#define CORK_CONFIG_ARCH_X64 0
#endif
#if defined(__powerpc__) || defined(__ppc__)
/* GCC-ish compiler */
#define CORK_CONFIG_ARCH_PPC 1
#elif defined(_M_PPC)
/* VS-ish compiler */
#define CORK_CONFIG_ARCH_PPC 1
#elif defined(_ARCH_PPC)
/* Something called XL C/C++? */
#define CORK_CONFIG_ARCH_PPC 1
#else
#define CORK_CONFIG_ARCH_PPC 0
#endif
#endif /* LIBCORK_CONFIG_ARCH_H */
|
281677160/openwrt-package | 1,162 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/config/mingw32.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CONFIG_MINGW32_H
#define LIBCORK_CONFIG_MINGW32_H
#include <io.h>
/*-----------------------------------------------------------------------
* Endianness
*/
/* Assume MinGW32 only works on x86 platform */
#define CORK_CONFIG_IS_BIG_ENDIAN 0
#define CORK_CONFIG_IS_LITTLE_ENDIAN 1
#define CORK_HAVE_REALLOCF 0
#define CORK_HAVE_PTHREADS 1
/*
* File io stuff. Odd that this is not defined by MinGW.
* Maybe there is an M$ish way to do it.
*/
#define F_SETFL 4
#define O_NONBLOCK 0x4000 /* non blocking I/O (POSIX style) */
#define F_GETFD 1
#define F_SETFD 2
#define FD_CLOEXEC 0x1
#define WNOHANG 1
/*
* simple adaptors
*/
static inline int mingw_mkdir(const char *path, int mode)
{
return mkdir(path);
}
#define mkdir mingw_mkdir
#define S_ISLNK(x) 0
#endif /* LIBCORK_CONFIG_MINGW32_H */
|
281677160/openwrt-package | 2,523 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/config/gcc.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CONFIG_GCC_H
#define LIBCORK_CONFIG_GCC_H
/* Figure out the GCC version */
#if defined(__GNUC_PATCHLEVEL__)
#define CORK_CONFIG_GCC_VERSION (__GNUC__ * 10000 \
+ __GNUC_MINOR__ * 100 \
+ __GNUC_PATCHLEVEL__)
#else
#define CORK_CONFIG_GCC_VERSION (__GNUC__ * 10000 \
+ __GNUC_MINOR__ * 100)
#endif
/*-----------------------------------------------------------------------
* Compiler attributes
*/
/* The GCC assembly syntax has been available basically forever. */
#if defined(CORK_CONFIG_GCC_VERSION)
#define CORK_CONFIG_HAVE_GCC_ASM 1
#else
#define CORK_CONFIG_HAVE_GCC_ASM 0
#endif
/* The GCC atomic instrinsics are available as of GCC 4.1.0. */
#if CORK_CONFIG_GCC_VERSION >= 40100
#define CORK_CONFIG_HAVE_GCC_ATOMICS 1
#else
#define CORK_CONFIG_HAVE_GCC_ATOMICS 0
#endif
/* The attributes we want to use are available as of GCC 2.96. */
#if CORK_CONFIG_GCC_VERSION >= 29600
#define CORK_CONFIG_HAVE_GCC_ATTRIBUTES 1
#else
#define CORK_CONFIG_HAVE_GCC_ATTRIBUTES 0
#endif
/* __int128 seems to be available on 64-bit platforms as of GCC 4.6. The
* attribute((mode(TI))) syntax seems to be available as of 4.1. */
#if CORK_CONFIG_ARCH_X64 && CORK_CONFIG_GCC_VERSION >= 40600
#define CORK_CONFIG_HAVE_GCC_INT128 1
#else
#define CORK_CONFIG_HAVE_GCC_INT128 0
#endif
#if CORK_CONFIG_ARCH_X64 && CORK_CONFIG_GCC_VERSION >= 40100
#define CORK_CONFIG_HAVE_GCC_MODE_ATTRIBUTE 1
#else
#define CORK_CONFIG_HAVE_GCC_MODE_ATTRIBUTE 0
#endif
/* Statement expressions have been available since GCC 3.1. */
#if CORK_CONFIG_GCC_VERSION >= 30100
#define CORK_CONFIG_HAVE_GCC_STATEMENT_EXPRS 1
#else
#define CORK_CONFIG_HAVE_GCC_STATEMENT_EXPRS 0
#endif
/* Thread-local storage has been available since GCC 3.3, but not on Mac
* OS X. Also disable TLS for uClibc*/
#if !(defined(__APPLE__) && defined(__MACH__))
#if CORK_CONFIG_GCC_VERSION >= 30300 && defined(TLS)
#define CORK_CONFIG_HAVE_THREAD_STORAGE_CLASS 1
#else
#define CORK_CONFIG_HAVE_THREAD_STORAGE_CLASS 0
#endif
#else
#define CORK_CONFIG_HAVE_THREAD_STORAGE_CLASS 0
#endif
#endif /* LIBCORK_CONFIG_GCC_H */
|
281677160/openwrt-package | 1,986 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/config/config.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011-2015, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CONFIG_CONFIG_H
#define LIBCORK_CONFIG_CONFIG_H
/* If you want to skip autodetection, define this to 1, and provide a
* libcork/config/custom.h header file. */
#if !defined(CORK_CONFIG_SKIP_AUTODETECT)
#define CORK_CONFIG_SKIP_AUTODETECT 0
#endif
#if CORK_CONFIG_SKIP_AUTODETECT
/* The user has promised that they'll define everything themselves. */
#include <libcork/config/custom.h>
#else
/* Otherwise autodetect! */
/**** VERSION ****/
#include <libcork/config/version.h>
/**** ARCHITECTURES ****/
#include <libcork/config/arch.h>
/**** PLATFORMS ****/
#if (defined(__unix__) || defined(unix)) && !defined(USG)
/* We need this to test for BSD, but it's a good idea to have for
* any brand of Unix.*/
#include <sys/param.h>
#endif
#if defined(__linux) || defined(__CYGWIN__) || defined(__FreeBSD_kernel__) || defined(__GNU__)
/* Do some Linux, kFreeBSD or GNU/Hurd specific autodetection. */
#include <libcork/config/linux.h>
#elif defined(__APPLE__) && defined(__MACH__)
/* Do some Mac OS X-specific autodetection. */
#include <libcork/config/macosx.h>
#elif defined(BSD) && (BSD >= 199103)
/* Do some BSD (4.3 code base or newer)specific autodetection. */
#include <libcork/config/bsd.h>
#elif defined(__MINGW32__)
/* Do some mingw32 autodetection. */
#include <libcork/config/mingw32.h>
#elif defined(__sun)
/* Do some Solaris autodetection. */
#include <libcork/config/solaris.h>
#endif /* platforms */
/**** COMPILERS ****/
#if defined(__GNUC__)
/* Do some GCC-specific autodetection. */
#include <libcork/config/gcc.h>
#endif /* compilers */
#endif /* autodetect or not */
#endif /* LIBCORK_CONFIG_CONFIG_H */
|
281677160/openwrt-package | 2,002 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/core/mempool.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2012-2015, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CORK_MEMPOOL_H
#define LIBCORK_CORK_MEMPOOL_H
#include <libcork/config.h>
#include <libcork/core/api.h>
#include <libcork/core/attributes.h>
#include <libcork/core/callbacks.h>
#include <libcork/core/types.h>
#define CORK_MEMPOOL_DEFAULT_BLOCK_SIZE 4096
struct cork_mempool;
CORK_API struct cork_mempool *
cork_mempool_new_size_ex(size_t element_size, size_t block_size);
#define cork_mempool_new_size(element_size) \
(cork_mempool_new_size_ex \
((element_size), CORK_MEMPOOL_DEFAULT_BLOCK_SIZE))
#define cork_mempool_new_ex(type, block_size) \
(cork_mempool_new_size_ex(sizeof(type), (block_size)))
#define cork_mempool_new(type) \
(cork_mempool_new_size(sizeof(type)))
CORK_API void
cork_mempool_free(struct cork_mempool *mp);
CORK_API void
cork_mempool_set_user_data(struct cork_mempool *mp,
void *user_data, cork_free_f free_user_data);
CORK_API void
cork_mempool_set_init_object(struct cork_mempool *mp, cork_init_f init_object);
CORK_API void
cork_mempool_set_done_object(struct cork_mempool *mp, cork_done_f done_object);
/* Deprecated; you should now use separate calls to cork_mempool_set_user_data,
* cork_mempool_set_init_object, and cork_mempool_set_done_object. */
CORK_API void
cork_mempool_set_callbacks(struct cork_mempool *mp,
void *user_data, cork_free_f free_user_data,
cork_init_f init_object,
cork_done_f done_object);
CORK_API void *
cork_mempool_new_object(struct cork_mempool *mp);
CORK_API void
cork_mempool_free_object(struct cork_mempool *mp, void *ptr);
#endif /* LIBCORK_CORK_MEMPOOL_H */
|
281677160/openwrt-package | 1,091 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/core/callbacks.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2013-2014, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CORE_CALLBACKS_H
#define LIBCORK_CORE_CALLBACKS_H
#include <libcork/core/hash.h>
typedef int
(*cork_copy_f)(void *user_data, void *dest, const void *src);
typedef void
(*cork_done_f)(void *user_data, void *value);
typedef void
(*cork_free_f)(void *value);
typedef cork_hash
(*cork_hash_f)(void *user_data, const void *value);
typedef bool
(*cork_equals_f)(void *user_data, const void *value1, const void *value2);
typedef void
(*cork_init_f)(void *user_data, void *value);
#define cork_free_user_data(parent) \
((parent)->free_user_data == NULL? (void) 0: \
(parent)->free_user_data((parent)->user_data))
typedef void *
(*cork_new_f)(void *user_data);
typedef int
(*cork_run_f)(void *user_data);
#endif /* LIBCORK_CORE_CALLBACKS_H */
|
281677160/openwrt-package | 4,322 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/core/attributes.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CORE_ATTRIBUTES_H
#define LIBCORK_CORE_ATTRIBUTES_H
#include <libcork/config.h>
/*
* Declare a “const” function.
*
* A const function is one whose return value depends only on its
* parameters. This is slightly more strict than a “pure” function; a
* const function is not allowed to read from global variables, whereas
* a pure function is.
*
* int square(int x) CORK_ATTR_CONST;
*/
#if CORK_CONFIG_HAVE_GCC_ATTRIBUTES
#define CORK_ATTR_CONST __attribute__((const))
#else
#define CORK_ATTR_CONST
#endif
/*
* Declare a “pure” function.
*
* A pure function is one whose return value depends only on its
* parameters, and global variables.
*
* int square(int x) CORK_ATTR_PURE;
*/
#if CORK_CONFIG_HAVE_GCC_ATTRIBUTES
#define CORK_ATTR_PURE __attribute__((pure))
#else
#define CORK_ATTR_PURE
#endif
/*
* Declare that a function returns a newly allocated pointer.
*
* The compiler can use this information to generate more accurate
* aliasing information, since it can infer that the result of the
* function cannot alias any other existing pointer.
*/
#if CORK_CONFIG_HAVE_GCC_ATTRIBUTES
#define CORK_ATTR_MALLOC __attribute__((malloc))
#else
#define CORK_ATTR_MALLOC
#endif
/*
* Declare that a function shouldn't be inlined.
*/
#if CORK_CONFIG_HAVE_GCC_ATTRIBUTES
#define CORK_ATTR_NOINLINE __attribute__((noinline))
#else
#define CORK_ATTR_NOINLINE
#endif
/*
* Declare an entity that isn't used.
*
* This lets you keep -Wall activated in several cases where you're
* obligated to define something that you don't intend to use.
*/
#if CORK_CONFIG_HAVE_GCC_ATTRIBUTES
#define CORK_ATTR_UNUSED __attribute__((unused))
#else
#define CORK_ATTR_UNUSED
#endif
/*
* Declare a function that takes in printf-like parameters.
*
* When the compiler supports this attribute, it will check the format
* string, and the following arguments, to make sure that they match.
* format_index and args_index are 1-based.
*/
#if CORK_CONFIG_HAVE_GCC_ATTRIBUTES && !(defined(__CYGWIN__)||defined(__MINGW32__))
#define CORK_ATTR_PRINTF(format_index, args_index) \
__attribute__((format(printf, format_index, args_index)))
#else
#define CORK_ATTR_PRINTF(format_index, args_index)
#endif
/*
* Declare a var-arg function whose last parameter must be a NULL
* sentinel value.
*
* When the compiler supports this attribute, it will check the actual
* parameters whenever this function is called, and ensure that the last
* parameter is a @c NULL.
*/
#if CORK_CONFIG_HAVE_GCC_ATTRIBUTES
#define CORK_ATTR_SENTINEL __attribute__((sentinel))
#else
#define CORK_ATTR_SENTINEL
#endif
/*
* Declare that a boolean expression is likely to be true or false.
*/
#if CORK_CONFIG_HAVE_GCC_ATTRIBUTES
#define CORK_LIKELY(expr) __builtin_expect((expr), 1)
#define CORK_UNLIKELY(expr) __builtin_expect((expr), 0)
#else
#define CORK_LIKELY(expr) (expr)
#define CORK_UNLIKELY(expr) (expr)
#endif
/*
* Declare that a function is part of the current library's public API, or that
* it's internal to the current library.
*/
#if CORK_CONFIG_HAVE_GCC_ATTRIBUTES && !(defined(__CYGWIN__)||defined(__MINGW32__))
#define CORK_EXPORT __attribute__((visibility("default")))
#define CORK_IMPORT __attribute__((visibility("default")))
#define CORK_LOCAL __attribute__((visibility("hidden")))
#else
#define CORK_EXPORT
#define CORK_IMPORT
#define CORK_LOCAL
#endif
/*
* Declare a static function that should automatically be called at program
* startup.
*/
/* TODO: When we implement a full Windows port, [1] describes how best to
* implement an initialization function under Visual Studio.
*
* [1] http://stackoverflow.com/questions/1113409/attribute-constructor-equivalent-in-vc
*/
#if CORK_CONFIG_HAVE_GCC_ATTRIBUTES
#define CORK_INITIALIZER(name) \
__attribute__((constructor)) \
static void \
name(void)
#else
#error "Don't know how to implement initialization functions of this platform"
#endif
#endif /* LIBCORK_CORE_ATTRIBUTES_H */
|
281677160/openwrt-package | 1,587 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/core/api.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2012-2015, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CORE_API_H
#define LIBCORK_CORE_API_H
#include <libcork/config.h>
#include <libcork/core/attributes.h>
/*-----------------------------------------------------------------------
* Calling conventions
*/
/* If you're using libcork as a shared library, you don't need to do anything
* special; the following will automatically set things up so that libcork's
* public symbols are imported from the library. When we build the shared
* library, we define this ourselves to export the symbols. */
#if !defined(CORK_API)
#define CORK_API CORK_IMPORT
#endif
/*-----------------------------------------------------------------------
* Library version
*/
#define CORK_VERSION_MAJOR CORK_CONFIG_VERSION_MAJOR
#define CORK_VERSION_MINOR CORK_CONFIG_VERSION_MINOR
#define CORK_VERSION_PATCH CORK_CONFIG_VERSION_PATCH
#define CORK_MAKE_VERSION(major, minor, patch) \
((major * 1000000) + (minor * 1000) + patch)
#define CORK_VERSION \
CORK_MAKE_VERSION(CORK_VERSION_MAJOR, \
CORK_VERSION_MINOR, \
CORK_VERSION_PATCH)
CORK_API const char *
cork_version_string(void)
CORK_ATTR_CONST;
CORK_API const char *
cork_revision_string(void)
CORK_ATTR_CONST;
#endif /* LIBCORK_CORE_API_H */
|
281677160/openwrt-package | 1,588 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/core/gc.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_GC_REFCOUNT_H
#define LIBCORK_GC_REFCOUNT_H
#include <libcork/core/api.h>
#include <libcork/core/types.h>
struct cork_gc;
/* A callback for recursing through the children of a garbage-collected
* object. */
typedef void
(*cork_gc_recurser)(struct cork_gc *gc, void *obj, void *ud);
typedef void
(*cork_gc_free_func)(void *obj);
typedef void
(*cork_gc_recurse_func)(struct cork_gc *gc, void *self,
cork_gc_recurser recurser, void *ud);
/* An interface that each garbage-collected object must implement. */
struct cork_gc_obj_iface {
/* Perform additional cleanup; does *NOT* need to deallocate the
* object itself, or release any child references */
cork_gc_free_func free;
cork_gc_recurse_func recurse;
};
CORK_API void
cork_gc_init(void);
CORK_API void
cork_gc_done(void);
CORK_API void *
cork_gc_alloc(size_t instance_size, struct cork_gc_obj_iface *iface);
#define cork_gc_new_iface(obj_type, iface) \
((obj_type *) \
(cork_gc_alloc(sizeof(obj_type), (iface))))
#define cork_gc_new(struct_name) \
(cork_gc_new_iface(struct struct_name, &struct_name##__gc))
CORK_API void *
cork_gc_incref(void *obj);
CORK_API void
cork_gc_decref(void *obj);
#endif /* LIBCORK_GC_REFCOUNT_H */
|
281677160/openwrt-package | 2,119 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/core/types.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CORE_TYPES_H
#define LIBCORK_CORE_TYPES_H
/* For now, we assume that the C99 integer types are available using the
* standard headers. */
#include <limits.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
/* Define preprocessor macros that contain the size of several built-in
* types. Again, we assume that we have the C99 definitions available. */
#if SHRT_MAX == INT8_MAX
#define CORK_SIZEOF_SHORT 1
#elif SHRT_MAX == INT16_MAX
#define CORK_SIZEOF_SHORT 2
#elif SHRT_MAX == INT32_MAX
#define CORK_SIZEOF_SHORT 4
#elif SHRT_MAX == INT64_MAX
#define CORK_SIZEOF_SHORT 8
#else
#error "Cannot determine size of short"
#endif
#if INT_MAX == INT8_MAX
#define CORK_SIZEOF_INT 1
#elif INT_MAX == INT16_MAX
#define CORK_SIZEOF_INT 2
#elif INT_MAX == INT32_MAX
#define CORK_SIZEOF_INT 4
#elif INT_MAX == INT64_MAX
#define CORK_SIZEOF_INT 8
#else
#error "Cannot determine size of int"
#endif
#if LONG_MAX == INT8_MAX
#define CORK_SIZEOF_LONG 1
#elif LONG_MAX == INT16_MAX
#define CORK_SIZEOF_LONG 2
#elif LONG_MAX == INT32_MAX
#define CORK_SIZEOF_LONG 4
#elif LONG_MAX == INT64_MAX
#define CORK_SIZEOF_LONG 8
#else
#error "Cannot determine size of long"
#endif
#if INTPTR_MAX == INT8_MAX
#define CORK_SIZEOF_POINTER 1
#elif INTPTR_MAX == INT16_MAX
#define CORK_SIZEOF_POINTER 2
#elif INTPTR_MAX == INT32_MAX
#define CORK_SIZEOF_POINTER 4
#elif INTPTR_MAX == INT64_MAX
#define CORK_SIZEOF_POINTER 8
#else
#error "Cannot determine size of void *"
#endif
/* Return a pointer to a @c struct, given a pointer to one of its
* fields. */
#define cork_container_of(field, struct_type, field_name) \
((struct_type *) (- offsetof(struct_type, field_name) + \
(void *) (field)))
#endif /* LIBCORK_CORE_TYPES_H */
|
281677160/openwrt-package | 10,664 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/core/hash.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011-2013, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CORE_HASH_H
#define LIBCORK_CORE_HASH_H
#include <libcork/core/api.h>
#include <libcork/core/attributes.h>
#include <libcork/core/byte-order.h>
#include <libcork/core/types.h>
#include <libcork/core/u128.h>
#ifndef CORK_HASH_ATTRIBUTES
#define CORK_HASH_ATTRIBUTES CORK_ATTR_UNUSED static inline
#endif
typedef uint32_t cork_hash;
typedef struct {
cork_u128 u128;
} cork_big_hash;
#define cork_big_hash_equal(h1, h2) (cork_u128_eq((h1).u128, (h2).u128))
#define CORK_BIG_HASH_INIT() {{{{0}}}}
/* We currently use MurmurHash3 [1], which is public domain, as our hash
* implementation.
*
* [1] http://code.google.com/p/smhasher/
*/
#define CORK_ROTL32(a,b) (((a) << ((b) & 0x1f)) | ((a) >> (32 - ((b) & 0x1f))))
#define CORK_ROTL64(a,b) (((a) << ((b) & 0x3f)) | ((a) >> (64 - ((b) & 0x3f))))
CORK_ATTR_UNUSED
static inline
uint32_t cork_fmix32(uint32_t h)
{
h ^= h >> 16;
h *= 0x85ebca6b;
h ^= h >> 13;
h *= 0xc2b2ae35;
h ^= h >> 16;
return h;
}
CORK_ATTR_UNUSED
static inline
uint64_t cork_fmix64(uint64_t k)
{
k ^= k >> 33;
k *= UINT64_C(0xff51afd7ed558ccd);
k ^= k >> 33;
k *= UINT64_C(0xc4ceb9fe1a85ec53);
k ^= k >> 33;
return k;
}
CORK_HASH_ATTRIBUTES
cork_hash
cork_stable_hash_buffer(cork_hash seed, const void *src, size_t len)
{
typedef uint32_t __attribute__((__may_alias__)) cork_aliased_uint32_t;
/* This is exactly the same as cork_murmur_hash_x86_32, but with a byte swap
* to make sure that we always process the uint32s little-endian. */
const unsigned int nblocks = len / 4;
const cork_aliased_uint32_t *blocks = (const cork_aliased_uint32_t *) src;
const cork_aliased_uint32_t *end = blocks + nblocks;
const cork_aliased_uint32_t *curr;
const uint8_t *tail = (const uint8_t *) end;
uint32_t h1 = seed;
uint32_t c1 = 0xcc9e2d51;
uint32_t c2 = 0x1b873593;
uint32_t k1 = 0;
/* body */
for (curr = blocks; curr != end; curr++) {
uint32_t k1 = CORK_UINT32_HOST_TO_LITTLE(*curr);
k1 *= c1;
k1 = CORK_ROTL32(k1,15);
k1 *= c2;
h1 ^= k1;
h1 = CORK_ROTL32(h1,13);
h1 = h1*5+0xe6546b64;
}
/* tail */
switch (len & 3) {
case 3: k1 ^= tail[2] << 16;
case 2: k1 ^= tail[1] << 8;
case 1: k1 ^= tail[0];
k1 *= c1; k1 = CORK_ROTL32(k1,15); k1 *= c2; h1 ^= k1;
};
/* finalization */
h1 ^= len;
h1 = cork_fmix32(h1);
return h1;
}
#define cork_murmur_hash_x86_32(seed, src, len, dest) \
do { \
typedef uint32_t __attribute__((__may_alias__)) cork_aliased_uint32_t; \
\
const unsigned int nblocks = len / 4; \
const cork_aliased_uint32_t *blocks = (const cork_aliased_uint32_t *) src; \
const cork_aliased_uint32_t *end = blocks + nblocks; \
const cork_aliased_uint32_t *curr; \
const uint8_t *tail = (const uint8_t *) end; \
\
uint32_t h1 = seed; \
uint32_t c1 = 0xcc9e2d51; \
uint32_t c2 = 0x1b873593; \
uint32_t k1 = 0; \
\
/* body */ \
for (curr = blocks; curr != end; curr++) { \
uint32_t k1 = *curr; \
\
k1 *= c1; \
k1 = CORK_ROTL32(k1,15); \
k1 *= c2; \
\
h1 ^= k1; \
h1 = CORK_ROTL32(h1,13); \
h1 = h1*5+0xe6546b64; \
} \
\
/* tail */ \
switch (len & 3) { \
case 3: k1 ^= tail[2] << 16; \
case 2: k1 ^= tail[1] << 8; \
case 1: k1 ^= tail[0]; \
k1 *= c1; k1 = CORK_ROTL32(k1,15); k1 *= c2; h1 ^= k1; \
}; \
\
/* finalization */ \
h1 ^= len; \
h1 = cork_fmix32(h1); \
*(dest) = h1; \
} while (0)
#define cork_murmur_hash_x86_128(seed, src, len, dest) \
do { \
typedef uint32_t __attribute__((__may_alias__)) cork_aliased_uint32_t; \
\
const unsigned int nblocks = len / 16; \
const cork_aliased_uint32_t *blocks = (const cork_aliased_uint32_t *) src; \
const cork_aliased_uint32_t *end = blocks + (nblocks * 4); \
const cork_aliased_uint32_t *curr; \
const uint8_t *tail = (const uint8_t *) end; \
\
uint32_t h1 = cork_u128_be32(seed.u128, 0); \
uint32_t h2 = cork_u128_be32(seed.u128, 1); \
uint32_t h3 = cork_u128_be32(seed.u128, 2); \
uint32_t h4 = cork_u128_be32(seed.u128, 3); \
\
uint32_t c1 = 0x239b961b; \
uint32_t c2 = 0xab0e9789; \
uint32_t c3 = 0x38b34ae5; \
uint32_t c4 = 0xa1e38b93; \
\
uint32_t k1 = 0; \
uint32_t k2 = 0; \
uint32_t k3 = 0; \
uint32_t k4 = 0; \
\
/* body */ \
for (curr = blocks; curr != end; curr += 4) { \
uint32_t k1 = curr[0]; \
uint32_t k2 = curr[1]; \
uint32_t k3 = curr[2]; \
uint32_t k4 = curr[3]; \
\
k1 *= c1; k1 = CORK_ROTL32(k1,15); k1 *= c2; h1 ^= k1; \
h1 = CORK_ROTL32(h1,19); h1 += h2; h1 = h1*5+0x561ccd1b; \
\
k2 *= c2; k2 = CORK_ROTL32(k2,16); k2 *= c3; h2 ^= k2; \
h2 = CORK_ROTL32(h2,17); h2 += h3; h2 = h2*5+0x0bcaa747; \
\
k3 *= c3; k3 = CORK_ROTL32(k3,17); k3 *= c4; h3 ^= k3; \
h3 = CORK_ROTL32(h3,15); h3 += h4; h3 = h3*5+0x96cd1c35; \
\
k4 *= c4; k4 = CORK_ROTL32(k4,18); k4 *= c1; h4 ^= k4; \
h4 = CORK_ROTL32(h4,13); h4 += h1; h4 = h4*5+0x32ac3b17; \
} \
\
/* tail */ \
switch (len & 15) { \
case 15: k4 ^= tail[14] << 16; \
case 14: k4 ^= tail[13] << 8; \
case 13: k4 ^= tail[12] << 0; \
k4 *= c4; k4 = CORK_ROTL32(k4,18); k4 *= c1; h4 ^= k4; \
\
case 12: k3 ^= tail[11] << 24; \
case 11: k3 ^= tail[10] << 16; \
case 10: k3 ^= tail[ 9] << 8; \
case 9: k3 ^= tail[ 8] << 0; \
k3 *= c3; k3 = CORK_ROTL32(k3,17); k3 *= c4; h3 ^= k3; \
\
case 8: k2 ^= tail[ 7] << 24; \
case 7: k2 ^= tail[ 6] << 16; \
case 6: k2 ^= tail[ 5] << 8; \
case 5: k2 ^= tail[ 4] << 0; \
k2 *= c2; k2 = CORK_ROTL32(k2,16); k2 *= c3; h2 ^= k2; \
\
case 4: k1 ^= tail[ 3] << 24; \
case 3: k1 ^= tail[ 2] << 16; \
case 2: k1 ^= tail[ 1] << 8; \
case 1: k1 ^= tail[ 0] << 0; \
k1 *= c1; k1 = CORK_ROTL32(k1,15); k1 *= c2; h1 ^= k1; \
}; \
\
/* finalization */ \
\
h1 ^= len; h2 ^= len; h3 ^= len; h4 ^= len; \
\
h1 += h2; h1 += h3; h1 += h4; \
h2 += h1; h3 += h1; h4 += h1; \
\
h1 = cork_fmix32(h1); \
h2 = cork_fmix32(h2); \
h3 = cork_fmix32(h3); \
h4 = cork_fmix32(h4); \
\
h1 += h2; h1 += h3; h1 += h4; \
h2 += h1; h3 += h1; h4 += h1; \
\
(dest)->u128 = cork_u128_from_32(h1, h2, h3, h4); \
} while (0)
#define cork_murmur_hash_x64_128(seed, src, len, dest) \
do { \
typedef uint64_t __attribute__((__may_alias__)) cork_aliased_uint64_t; \
\
const unsigned int nblocks = len / 16; \
const cork_aliased_uint64_t *blocks = (const cork_aliased_uint64_t *) src; \
const cork_aliased_uint64_t *end = blocks + (nblocks * 2); \
const cork_aliased_uint64_t *curr; \
const uint8_t *tail = (const uint8_t *) end; \
\
uint64_t h1 = cork_u128_be64(seed.u128, 0); \
uint64_t h2 = cork_u128_be64(seed.u128, 1); \
\
uint64_t c1 = UINT64_C(0x87c37b91114253d5); \
uint64_t c2 = UINT64_C(0x4cf5ad432745937f); \
\
uint64_t k1 = 0; \
uint64_t k2 = 0; \
\
/* body */ \
for (curr = blocks; curr != end; curr += 2) { \
uint64_t k1 = curr[0]; \
uint64_t k2 = curr[1]; \
\
k1 *= c1; k1 = CORK_ROTL64(k1,31); k1 *= c2; h1 ^= k1; \
h1 = CORK_ROTL64(h1,27); h1 += h2; h1 = h1*5+0x52dce729; \
\
k2 *= c2; k2 = CORK_ROTL64(k2,33); k2 *= c1; h2 ^= k2; \
h2 = CORK_ROTL64(h2,31); h2 += h1; h2 = h2*5+0x38495ab5; \
} \
\
/* tail */ \
switch (len & 15) { \
case 15: k2 ^= (uint64_t) (tail[14]) << 48; \
case 14: k2 ^= (uint64_t) (tail[13]) << 40; \
case 13: k2 ^= (uint64_t) (tail[12]) << 32; \
case 12: k2 ^= (uint64_t) (tail[11]) << 24; \
case 11: k2 ^= (uint64_t) (tail[10]) << 16; \
case 10: k2 ^= (uint64_t) (tail[ 9]) << 8; \
case 9: k2 ^= (uint64_t) (tail[ 8]) << 0; \
k2 *= c2; k2 = CORK_ROTL64(k2,33); k2 *= c1; h2 ^= k2; \
\
case 8: k1 ^= (uint64_t) (tail[ 7]) << 56; \
case 7: k1 ^= (uint64_t) (tail[ 6]) << 48; \
case 6: k1 ^= (uint64_t) (tail[ 5]) << 40; \
case 5: k1 ^= (uint64_t) (tail[ 4]) << 32; \
case 4: k1 ^= (uint64_t) (tail[ 3]) << 24; \
case 3: k1 ^= (uint64_t) (tail[ 2]) << 16; \
case 2: k1 ^= (uint64_t) (tail[ 1]) << 8; \
case 1: k1 ^= (uint64_t) (tail[ 0]) << 0; \
k1 *= c1; k1 = CORK_ROTL64(k1,31); k1 *= c2; h1 ^= k1; \
}; \
\
/* finalization */ \
\
h1 ^= len; h2 ^= len; \
\
h1 += h2; \
h2 += h1; \
\
h1 = cork_fmix64(h1); \
h2 = cork_fmix64(h2); \
\
h1 += h2; \
h2 += h1; \
\
(dest)->u128 = cork_u128_from_64(h1, h2); \
} while (0)
#include <stdio.h>
CORK_HASH_ATTRIBUTES
cork_hash
cork_hash_buffer(cork_hash seed, const void *src, size_t len)
{
#if CORK_SIZEOF_POINTER == 8
cork_big_hash big_seed = {cork_u128_from_32(seed, seed, seed, seed)};
cork_big_hash hash;
cork_murmur_hash_x64_128(big_seed, src, len, &hash);
return cork_u128_be32(hash.u128, 0);
#else
cork_hash hash = 0;
cork_murmur_hash_x86_32(seed, src, len, &hash);
return hash;
#endif
}
CORK_HASH_ATTRIBUTES
cork_big_hash
cork_big_hash_buffer(cork_big_hash seed, const void *src, size_t len)
{
cork_big_hash result;
#if CORK_SIZEOF_POINTER == 8
cork_murmur_hash_x64_128(seed, src, len, &result);
#else
cork_murmur_hash_x86_128(seed, src, len, &result);
#endif
return result;
}
#define cork_hash_variable(seed, val) \
(cork_hash_buffer((seed), &(val), sizeof((val))))
#define cork_stable_hash_variable(seed, val) \
(cork_stable_hash_buffer((seed), &(val), sizeof((val))))
#define cork_big_hash_variable(seed, val) \
(cork_big_hash_buffer((seed), &(val), sizeof((val))))
#endif /* LIBCORK_CORE_HASH_H */
|
281677160/openwrt-package | 11,439 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/core/allocator.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011-2014, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CORE_ALLOCATOR_H
#define LIBCORK_CORE_ALLOCATOR_H
#include <assert.h>
#include <stdlib.h>
#include <libcork/core/api.h>
#include <libcork/core/attributes.h>
#include <libcork/core/callbacks.h>
#include <libcork/core/error.h>
#include <libcork/core/types.h>
/*-----------------------------------------------------------------------
* Allocator interface
*/
struct cork_alloc;
typedef void *
(*cork_alloc_calloc_f)(const struct cork_alloc *alloc,
size_t count, size_t size);
typedef void *
(*cork_alloc_malloc_f)(const struct cork_alloc *alloc, size_t size);
/* Must not free `ptr` if allocation fails. */
typedef void *
(*cork_alloc_realloc_f)(const struct cork_alloc *alloc, void *ptr,
size_t old_size, size_t new_size);
typedef void
(*cork_alloc_free_f)(const struct cork_alloc *alloc, void *ptr, size_t size);
struct cork_alloc {
const struct cork_alloc *parent;
void *user_data;
cork_free_f free_user_data;
cork_alloc_calloc_f calloc;
cork_alloc_malloc_f malloc;
cork_alloc_realloc_f realloc;
cork_alloc_calloc_f xcalloc;
cork_alloc_malloc_f xmalloc;
cork_alloc_realloc_f xrealloc;
cork_alloc_free_f free;
};
/* NOT thread-safe; must be called before most other libcork functions.
* Allocator will automatically be freed at process exit. */
CORK_API struct cork_alloc *
cork_alloc_new_alloc(const struct cork_alloc *parent);
CORK_API void
cork_alloc_set_user_data(struct cork_alloc *alloc,
void *user_data, cork_free_f free_user_data);
/* These variants must always return a valid pointer. If allocation fails, they
* should abort the process or transfer control in some other way to an error
* handler or cleanup routine.
*
* If you only provide implementations of the `x` variants, we'll provide
* default implementations of these that abort the process if a memory
* allocation fails. */
CORK_API void
cork_alloc_set_calloc(struct cork_alloc *alloc, cork_alloc_calloc_f calloc);
CORK_API void
cork_alloc_set_malloc(struct cork_alloc *alloc, cork_alloc_malloc_f malloc);
CORK_API void
cork_alloc_set_realloc(struct cork_alloc *alloc, cork_alloc_realloc_f realloc);
/* These variants can return a NULL pointer if allocation fails. */
CORK_API void
cork_alloc_set_xcalloc(struct cork_alloc *alloc, cork_alloc_calloc_f xcalloc);
CORK_API void
cork_alloc_set_xmalloc(struct cork_alloc *alloc, cork_alloc_malloc_f xmalloc);
CORK_API void
cork_alloc_set_xrealloc(struct cork_alloc *alloc,
cork_alloc_realloc_f xrealloc);
CORK_API void
cork_alloc_set_free(struct cork_alloc *alloc, cork_alloc_free_f free);
/* Low-level use of an allocator. */
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static void *
cork_alloc_calloc(const struct cork_alloc *alloc, size_t count, size_t size)
{
return alloc->calloc(alloc, count, size);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static void *
cork_alloc_malloc(const struct cork_alloc *alloc, size_t size)
{
return alloc->malloc(alloc, size);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static void *
cork_alloc_realloc(const struct cork_alloc *alloc, void *ptr,
size_t old_size, size_t new_size)
{
return alloc->realloc(alloc, ptr, old_size, new_size);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static void *
cork_alloc_xcalloc(const struct cork_alloc *alloc, size_t count, size_t size)
{
return alloc->xcalloc(alloc, count, size);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static void *
cork_alloc_xmalloc(const struct cork_alloc *alloc, size_t size)
{
return alloc->xmalloc(alloc, size);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static void *
cork_alloc_xrealloc(const struct cork_alloc *alloc, void *ptr,
size_t old_size, size_t new_size)
{
return alloc->xrealloc(alloc, ptr, old_size, new_size);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static void *
cork_alloc_xreallocf(const struct cork_alloc *alloc, void *ptr,
size_t old_size, size_t new_size)
{
void *result = alloc->xrealloc(alloc, ptr, old_size, new_size);
if (result == NULL) {
alloc->free(alloc, ptr, old_size);
return NULL;
} else {
return result;
}
}
CORK_ATTR_UNUSED
static void
cork_alloc_free(const struct cork_alloc *alloc, void *ptr, size_t size)
{
return alloc->free(alloc, ptr, size);
}
CORK_ATTR_UNUSED
static void
cork_alloc_cfree(const struct cork_alloc *alloc, void *ptr,
size_t count, size_t size)
{
assert(count < (SIZE_MAX / size));
return alloc->free(alloc, ptr, count * size);
}
#define cork_alloc_new(alloc, type) \
cork_alloc_malloc((alloc), sizeof(type))
#define cork_alloc_xnew(alloc, type) \
cork_alloc_xmalloc((alloc), sizeof(type))
#define cork_alloc_delete(alloc, type, ptr) \
cork_alloc_free((alloc), (ptr), sizeof(type))
/* string-related helper functions */
CORK_ATTR_MALLOC
CORK_API const char *
cork_alloc_strdup(const struct cork_alloc *alloc, const char *str);
CORK_ATTR_MALLOC
CORK_API const char *
cork_alloc_strndup(const struct cork_alloc *alloc,
const char *str, size_t size);
CORK_ATTR_MALLOC
CORK_API const char *
cork_alloc_xstrdup(const struct cork_alloc *alloc, const char *str);
CORK_ATTR_MALLOC
CORK_API const char *
cork_alloc_xstrndup(const struct cork_alloc *alloc,
const char *str, size_t size);
CORK_API void
cork_alloc_strfree(const struct cork_alloc *alloc, const char *str);
/*-----------------------------------------------------------------------
* Using the allocator interface
*/
/* All of the functions that you use to actually allocate memory assume that
* cork_current_allocator() returns the allocator instance that should be used.
* Your easiest approach is to do nothing special; in that case, all of the
* libcork memory allocation functions will transparently use the standard
* malloc/free family of functions.
*
* If you're writing a library, and want to allow your library clients to
* provide a separate custom memory allocator then the one they can already
* override for libcork itself, you should declare a pair of functions for
* getting and setting your library's current allocator (like libcork itself
* does), and (only when compiling the source of your library) define
* `cork_current_allocator` as a macro that aliases the getter function. That
* will cause the libcork memory allocation functions to use whichever allocator
* your library user has provided.
*
* If you're writing an application, and want to provide a single allocator that
* all libcork-using libraries will pick up, just call cork_set_allocator before
* calling any other library functions. Other libraries will use this as a
* default and everything that uses libcork's memory allocation functions will
* use your custom allocator. */
/* libcork's current allocator */
extern const struct cork_alloc *cork_allocator;
/* We take control and will free when the process exits. This is *NOT*
* thread-safe; it's only safe to call before you've called *ANY* other libcork
* function (or any function from any other library that uses libcork). You can
* only call this at most once. */
CORK_API void
cork_set_allocator(const struct cork_alloc *alloc);
/* The current allocator of whichever library is being compiled. */
#if !defined(cork_current_allocator)
#define cork_current_allocator() (cork_allocator)
#endif
/* using an allocator */
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static void *
cork_calloc(size_t count, size_t size)
{
const struct cork_alloc *alloc = cork_current_allocator();
return cork_alloc_calloc(alloc, count, size);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static void *
cork_malloc(size_t size)
{
const struct cork_alloc *alloc = cork_current_allocator();
return cork_alloc_malloc(alloc, size);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static void *
cork_realloc(void *ptr, size_t old_size, size_t new_size)
{
const struct cork_alloc *alloc = cork_current_allocator();
return cork_alloc_realloc(alloc, ptr, old_size, new_size);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static void *
cork_xcalloc(size_t count, size_t size)
{
const struct cork_alloc *alloc = cork_current_allocator();
return cork_alloc_xcalloc(alloc, count, size);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static void *
cork_xmalloc(size_t size)
{
const struct cork_alloc *alloc = cork_current_allocator();
return cork_alloc_xmalloc(alloc, size);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static void *
cork_xrealloc(void *ptr, size_t old_size, size_t new_size)
{
const struct cork_alloc *alloc = cork_current_allocator();
return cork_alloc_xrealloc(alloc, ptr, old_size, new_size);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static void *
cork_xreallocf(void *ptr, size_t old_size, size_t new_size)
{
const struct cork_alloc *alloc = cork_current_allocator();
return cork_alloc_xreallocf(alloc, ptr, old_size, new_size);
}
CORK_ATTR_UNUSED
static void
cork_free(void *ptr, size_t size)
{
const struct cork_alloc *alloc = cork_current_allocator();
cork_alloc_free(alloc, ptr, size);
}
CORK_ATTR_UNUSED
static void
cork_cfree(void *ptr, size_t count, size_t size)
{
const struct cork_alloc *alloc = cork_current_allocator();
cork_alloc_cfree(alloc, ptr, count, size);
}
#define cork_new(type) cork_malloc(sizeof(type))
#define cork_xnew(type) cork_xmalloc(sizeof(type))
#define cork_delete(type, ptr) cork_free((ptr), sizeof(type))
/* string-related helper functions */
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static const char *
cork_strdup(const char *str)
{
const struct cork_alloc *alloc = cork_current_allocator();
return cork_alloc_strdup(alloc, str);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static const char *
cork_strndup(const char *str, size_t size)
{
const struct cork_alloc *alloc = cork_current_allocator();
return cork_alloc_strndup(alloc, str, size);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static const char *
cork_xstrdup(const char *str)
{
const struct cork_alloc *alloc = cork_current_allocator();
return cork_alloc_xstrdup(alloc, str);
}
CORK_ATTR_MALLOC
CORK_ATTR_UNUSED
static const char *
cork_xstrndup(const char *str, size_t size)
{
const struct cork_alloc *alloc = cork_current_allocator();
return cork_alloc_xstrndup(alloc, str, size);
}
CORK_ATTR_UNUSED
static void
cork_strfree(const char *str)
{
const struct cork_alloc *alloc = cork_current_allocator();
return cork_alloc_strfree(alloc, str);
}
/*-----------------------------------------------------------------------
* Debugging allocator
*/
/* An allocator that adds some additional debugging checks:
*
* - We verify that every "free" call (cork_free, cork_cfree, cork_delete,
* cork_realloc) is passed the "correct" size — i.e., the same size that was
* passed in to the correspond "new" call (cork_malloc, cork_calloc,
* cork_realloc, cork_new).
*/
struct cork_alloc *
cork_debug_alloc_new(const struct cork_alloc *parent);
#endif /* LIBCORK_CORE_ALLOCATOR_H */
|
281677160/openwrt-package | 3,446 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/core/error.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011-2013, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CORE_ERROR_H
#define LIBCORK_CORE_ERROR_H
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <libcork/core/api.h>
#include <libcork/core/attributes.h>
#include <libcork/core/types.h>
/* Should be a hash of a string representing the error code. */
typedef uint32_t cork_error;
/* An error code that represents “no error”. */
#define CORK_ERROR_NONE ((cork_error) 0)
CORK_API bool
cork_error_occurred(void);
CORK_API cork_error
cork_error_code(void);
CORK_API const char *
cork_error_message(void);
CORK_API void
cork_error_clear(void);
CORK_API void
cork_error_set_printf(cork_error code, const char *format, ...)
CORK_ATTR_PRINTF(2,3);
CORK_API void
cork_error_set_string(cork_error code, const char *str);
CORK_API void
cork_error_set_vprintf(cork_error code, const char *format, va_list args)
CORK_ATTR_PRINTF(2,0);
CORK_API void
cork_error_prefix_printf(const char *format, ...)
CORK_ATTR_PRINTF(1,2);
CORK_API void
cork_error_prefix_string(const char *str);
CORK_API void
cork_error_prefix_vprintf(const char *format, va_list arg)
CORK_ATTR_PRINTF(1,0);
/* deprecated */
CORK_API void
cork_error_set(uint32_t error_class, unsigned int error_code,
const char *format, ...)
CORK_ATTR_PRINTF(3,4);
/* deprecated */
CORK_API void
cork_error_prefix(const char *format, ...)
CORK_ATTR_PRINTF(1,2);
/*-----------------------------------------------------------------------
* Built-in errors
*/
#define CORK_PARSE_ERROR 0x95dfd3c8
#define CORK_REDEFINED 0x171629cb
#define CORK_UNDEFINED 0xedc3d7d9
#define CORK_UNKNOWN_ERROR 0x8cb0880d
#define cork_parse_error(...) \
cork_error_set_printf(CORK_PARSE_ERROR, __VA_ARGS__)
#define cork_redefined(...) \
cork_error_set_printf(CORK_REDEFINED, __VA_ARGS__)
#define cork_undefined(...) \
cork_error_set_printf(CORK_UNDEFINED, __VA_ARGS__)
CORK_API void
cork_system_error_set(void);
CORK_API void
cork_system_error_set_explicit(int err);
CORK_API void
cork_unknown_error_set_(const char *location);
#define cork_unknown_error() \
cork_unknown_error_set_(__func__)
/*-----------------------------------------------------------------------
* Abort on failure
*/
#define cork_abort_(func, file, line, fmt, ...) \
do { \
fprintf(stderr, fmt "\n in %s (%s:%u)\n", \
__VA_ARGS__, (func), (file), (unsigned int) (line)); \
abort(); \
} while (0)
#define cork_abort(fmt, ...) \
cork_abort_(__func__, __FILE__, __LINE__, fmt, __VA_ARGS__)
CORK_ATTR_UNUSED
static void *
cork_abort_if_null_(void *ptr, const char *msg, const char *func,
const char *file, unsigned int line)
{
if (CORK_UNLIKELY(ptr == NULL)) {
cork_abort_(func, file, line, "%s", msg);
} else {
return ptr;
}
}
#define cork_abort_if_null(ptr, msg) \
(cork_abort_if_null_(ptr, msg, __func__, __FILE__, __LINE__))
#define cork_unreachable() \
cork_abort("%s", "Code should not be reachable")
#endif /* LIBCORK_CORE_ERROR_H */
|
281677160/openwrt-package | 7,358 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/core/byte-order.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CORE_BYTE_ORDER_H
#define LIBCORK_CORE_BYTE_ORDER_H
#include <libcork/config.h>
#include <libcork/core/types.h>
/* Constants to represent big endianness and little endianness */
#define CORK_BIG_ENDIAN 4321
#define CORK_LITTLE_ENDIAN 1234
/* Whether the current host is big- or little-endian. HOST gives us the
* current system's endianness; OTHER gives the opposite endianness.
* The _NAME macros can be used in debugging messages and other
* human-readable output.
*
* Note that we actually detect the endianness in the various header
* files in the libcork/config directory, since we want to keep
* everything detection-related separated out from what we define based
* on that detection. */
#if CORK_CONFIG_IS_BIG_ENDIAN
#define CORK_HOST_ENDIANNESS CORK_BIG_ENDIAN
#define CORK_OTHER_ENDIANNESS CORK_LITTLE_ENDIAN
#define CORK_HOST_ENDIANNESS_NAME "big"
#define CORK_OTHER_ENDIANNESS_NAME "little"
#elif CORK_CONFIG_IS_LITTLE_ENDIAN
#define CORK_HOST_ENDIANNESS CORK_LITTLE_ENDIAN
#define CORK_OTHER_ENDIANNESS CORK_BIG_ENDIAN
#define CORK_HOST_ENDIANNESS_NAME "little"
#define CORK_OTHER_ENDIANNESS_NAME "big"
#else
#error "Unknown endianness"
#endif
/* Returns the byte-swapped version an integer, regardless of the
* underlying endianness.
*
* These macros only require an rvalue as their parameter (which can
* therefore be any arbitrary expression), and they don't modify the
* original contents if it happens to be a variable. */
#define CORK_SWAP_UINT16(__u16) \
(((((uint16_t) __u16) & 0xff00u) >> 8) | \
((((uint16_t) __u16) & 0x00ffu) << 8))
#define CORK_SWAP_UINT32(__u32) \
(((((uint32_t) __u32) & 0xff000000u) >> 24) | \
((((uint32_t) __u32) & 0x00ff0000u) >> 8) | \
((((uint32_t) __u32) & 0x0000ff00u) << 8) | \
((((uint32_t) __u32) & 0x000000ffu) << 24))
#define CORK_SWAP_UINT64(__u64) \
(((((uint64_t) __u64) & UINT64_C(0xff00000000000000)) >> 56) | \
((((uint64_t) __u64) & UINT64_C(0x00ff000000000000)) >> 40) | \
((((uint64_t) __u64) & UINT64_C(0x0000ff0000000000)) >> 24) | \
((((uint64_t) __u64) & UINT64_C(0x000000ff00000000)) >> 8) | \
((((uint64_t) __u64) & UINT64_C(0x00000000ff000000)) << 8) | \
((((uint64_t) __u64) & UINT64_C(0x0000000000ff0000)) << 24) | \
((((uint64_t) __u64) & UINT64_C(0x000000000000ff00)) << 40) | \
((((uint64_t) __u64) & UINT64_C(0x00000000000000ff)) << 56))
/* Bytes-swaps an integer variable in place.
*
* These macros require an lvalue as their parameter; the contents of
* this variable will be modified by the macro. */
#define CORK_SWAP_IN_PLACE_UINT16(__u16) \
do { \
(__u16) = CORK_SWAP_UINT16(__u16); \
} while (0)
#define CORK_SWAP_IN_PLACE_UINT32(__u32) \
do { \
(__u32) = CORK_SWAP_UINT32(__u32); \
} while (0)
#define CORK_SWAP_IN_PLACE_UINT64(__u64) \
do { \
(__u64) = CORK_SWAP_UINT64(__u64); \
} while (0)
/*
* A slew of swapping macros whose operation depends on the endianness
* of the current system:
*
* uint16_t CORK_UINT16_BIG_TO_HOST(u16)
* uint32_t CORK_UINT32_BIG_TO_HOST(u32)
* uint64_t CORK_UINT64_BIG_TO_HOST(u64)
* uint16_t CORK_UINT16_LITTLE_TO_HOST(u16)
* uint32_t CORK_UINT32_LITTLE_TO_HOST(u32)
* uint64_t CORK_UINT64_LITTLE_TO_HOST(u64)
* void CORK_UINT16_BIG_TO_HOST_IN_PLACE(&u16)
* void CORK_UINT32_BIG_TO_HOST_IN_PLACE(&u32)
* void CORK_UINT64_BIG_TO_HOST_IN_PLACE(&u64)
* void CORK_UINT16_LITTLE_TO_HOST_IN_PLACE(&u16)
* void CORK_UINT32_LITTLE_TO_HOST_IN_PLACE(&u32)
* void CORK_UINT64_LITTLE_TO_HOST_IN_PLACE(&u64)
*
* uint16_t CORK_UINT16_HOST_TO_BIG(u16)
* uint32_t CORK_UINT32_HOST_TO_BIG(u32)
* uint64_t CORK_UINT64_HOST_TO_BIG(u64)
* uint16_t CORK_UINT16_HOST_TO_LITTLE(u16)
* uint32_t CORK_UINT32_HOST_TO_LITTLE(u32)
* uint64_t CORK_UINT64_HOST_TO_LITTLE(u64)
* void CORK_UINT16_HOST_TO_BIG_IN_PLACE(&u16)
* void CORK_UINT32_HOST_TO_BIG_IN_PLACE(&u32)
* void CORK_UINT64_HOST_TO_BIG_IN_PLACE(&u64)
* void CORK_UINT16_HOST_TO_LITTLE_IN_PLACE(&u16)
* void CORK_UINT32_HOST_TO_LITTLE_IN_PLACE(&u32)
* void CORK_UINT64_HOST_TO_LITTLE_IN_PLACE(&u64)
*/
#if CORK_HOST_ENDIANNESS == CORK_BIG_ENDIAN
#define CORK_UINT16_BIG_TO_HOST(__u16) (__u16) /* nothing to do */
#define CORK_UINT16_LITTLE_TO_HOST(__u16) CORK_SWAP_UINT16(__u16)
#define CORK_UINT32_BIG_TO_HOST(__u32) (__u32) /* nothing to do */
#define CORK_UINT32_LITTLE_TO_HOST(__u32) CORK_SWAP_UINT32(__u32)
#define CORK_UINT64_BIG_TO_HOST(__u64) (__u64) /* nothing to do */
#define CORK_UINT64_LITTLE_TO_HOST(__u64) CORK_SWAP_UINT64(__u64)
#define CORK_UINT16_BIG_TO_HOST_IN_PLACE(__u16) /* nothing to do */
#define CORK_UINT16_LITTLE_TO_HOST_IN_PLACE(__u16) CORK_SWAP_IN_PLACE_UINT16(__u16)
#define CORK_UINT32_BIG_TO_HOST_IN_PLACE(__u32) /* nothing to do */
#define CORK_UINT32_LITTLE_TO_HOST_IN_PLACE(__u32) CORK_SWAP_IN_PLACE_UINT32(__u32)
#define CORK_UINT64_BIG_TO_HOST_IN_PLACE(__u64) /* nothing to do */
#define CORK_UINT64_LITTLE_TO_HOST_IN_PLACE(__u64) CORK_SWAP_IN_PLACE_UINT64(__u64)
#elif CORK_HOST_ENDIANNESS == CORK_LITTLE_ENDIAN
#define CORK_UINT16_BIG_TO_HOST(__u16) CORK_SWAP_UINT16(__u16)
#define CORK_UINT16_LITTLE_TO_HOST(__u16) (__u16) /* nothing to do */
#define CORK_UINT32_BIG_TO_HOST(__u32) CORK_SWAP_UINT32(__u32)
#define CORK_UINT32_LITTLE_TO_HOST(__u32) (__u32) /* nothing to do */
#define CORK_UINT64_BIG_TO_HOST(__u64) CORK_SWAP_UINT64(__u64)
#define CORK_UINT64_LITTLE_TO_HOST(__u64) (__u64) /* nothing to do */
#define CORK_UINT16_BIG_TO_HOST_IN_PLACE(__u16) CORK_SWAP_IN_PLACE_UINT16(__u16)
#define CORK_UINT16_LITTLE_TO_HOST_IN_PLACE(__u16) /* nothing to do */
#define CORK_UINT32_BIG_TO_HOST_IN_PLACE(__u32) CORK_SWAP_IN_PLACE_UINT32(__u32)
#define CORK_UINT32_LITTLE_TO_HOST_IN_PLACE(__u32) /* nothing to do */
#define CORK_UINT64_BIG_TO_HOST_IN_PLACE(__u64) CORK_SWAP_IN_PLACE_UINT64(__u64)
#define CORK_UINT64_LITTLE_TO_HOST_IN_PLACE(__u64) /* nothing to do */
#endif
#define CORK_UINT16_HOST_TO_BIG(__u16) CORK_UINT16_BIG_TO_HOST(__u16)
#define CORK_UINT32_HOST_TO_BIG(__u32) CORK_UINT32_BIG_TO_HOST(__u32)
#define CORK_UINT64_HOST_TO_BIG(__u64) CORK_UINT64_BIG_TO_HOST(__u64)
#define CORK_UINT16_HOST_TO_LITTLE(__u16) CORK_UINT16_LITTLE_TO_HOST(__u16)
#define CORK_UINT32_HOST_TO_LITTLE(__u32) CORK_UINT32_LITTLE_TO_HOST(__u32)
#define CORK_UINT64_HOST_TO_LITTLE(__u64) CORK_UINT64_LITTLE_TO_HOST(__u64)
#define CORK_UINT16_HOST_TO_BIG_IN_PLACE(__u16) CORK_UINT16_BIG_TO_HOST_IN_PLACE(__u16)
#define CORK_UINT32_HOST_TO_BIG_IN_PLACE(__u32) CORK_UINT32_BIG_TO_HOST_IN_PLACE(__u32)
#define CORK_UINT64_HOST_TO_BIG_IN_PLACE(__u64) CORK_UINT64_BIG_TO_HOST_IN_PLACE(__u64)
#define CORK_UINT16_HOST_TO_LITTLE_IN_PLACE(__u16) CORK_UINT16_LITTLE_TO_HOST_IN_PLACE(__u16)
#define CORK_UINT32_HOST_TO_LITTLE_IN_PLACE(__u32) CORK_UINT32_LITTLE_TO_HOST_IN_PLACE(__u32)
#define CORK_UINT64_HOST_TO_LITTLE_IN_PLACE(__u64) CORK_UINT64_LITTLE_TO_HOST_IN_PLACE(__u64)
#endif /* LIBCORK_CORE_BYTE_ORDER_H */
|
281677160/openwrt-package | 5,101 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/core/u128.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2013, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CORE_U128_H
#define LIBCORK_CORE_U128_H
#include <libcork/config.h>
#include <libcork/core/attributes.h>
#include <libcork/core/byte-order.h>
#include <libcork/core/types.h>
typedef struct {
union {
uint8_t u8[16];
uint16_t u16[8];
uint32_t u32[4];
uint64_t u64[2];
#if CORK_HOST_ENDIANNESS == CORK_BIG_ENDIAN
struct { uint64_t hi; uint64_t lo; } be64;
#else
struct { uint64_t lo; uint64_t hi; } be64;
#endif
#if CORK_CONFIG_HAVE_GCC_INT128
#define CORK_U128_HAVE_U128 1
unsigned __int128 u128;
#elif CORK_CONFIG_HAVE_GCC_MODE_ATTRIBUTE
#define CORK_U128_HAVE_U128 1
unsigned int u128 __attribute__((mode(TI)));
#else
#define CORK_U128_HAVE_U128 0
#endif
} _;
} cork_u128;
/* i0-3 are given in big-endian order, regardless of host endianness */
CORK_ATTR_UNUSED
static cork_u128
cork_u128_from_32(uint32_t i0, uint32_t i1, uint32_t i2, uint32_t i3)
{
cork_u128 value;
#if CORK_HOST_ENDIANNESS == CORK_BIG_ENDIAN
value._.u32[0] = i0;
value._.u32[1] = i1;
value._.u32[2] = i2;
value._.u32[3] = i3;
#else
value._.u32[3] = i0;
value._.u32[2] = i1;
value._.u32[1] = i2;
value._.u32[0] = i3;
#endif
return value;
}
/* i0-1 are given in big-endian order, regardless of host endianness */
CORK_ATTR_UNUSED
static cork_u128
cork_u128_from_64(uint64_t i0, uint64_t i1)
{
cork_u128 value;
#if CORK_HOST_ENDIANNESS == CORK_BIG_ENDIAN
value._.u64[0] = i0;
value._.u64[1] = i1;
#else
value._.u64[1] = i0;
value._.u64[0] = i1;
#endif
return value;
}
#if CORK_HOST_ENDIANNESS == CORK_BIG_ENDIAN
#define cork_u128_be8(val, idx) ((val)._.u8[(idx)])
#define cork_u128_be16(val, idx) ((val)._.u16[(idx)])
#define cork_u128_be32(val, idx) ((val)._.u32[(idx)])
#define cork_u128_be64(val, idx) ((val)._.u64[(idx)])
#else
#define cork_u128_be8(val, idx) ((val)._.u8[15 - (idx)])
#define cork_u128_be16(val, idx) ((val)._.u16[7 - (idx)])
#define cork_u128_be32(val, idx) ((val)._.u32[3 - (idx)])
#define cork_u128_be64(val, idx) ((val)._.u64[1 - (idx)])
#endif
CORK_ATTR_UNUSED
static cork_u128
cork_u128_add(cork_u128 a, cork_u128 b)
{
cork_u128 result;
#if CORK_U128_HAVE_U128
result._.u128 = a._.u128 + b._.u128;
#else
result._.be64.lo = a._.be64.lo + b._.be64.lo;
result._.be64.hi =
a._.be64.hi + b._.be64.hi + (result._.be64.lo < a._.be64.lo);
#endif
return result;
}
CORK_ATTR_UNUSED
static cork_u128
cork_u128_sub(cork_u128 a, cork_u128 b)
{
cork_u128 result;
#if CORK_U128_HAVE_U128
result._.u128 = a._.u128 - b._.u128;
#else
result._.be64.lo = a._.be64.lo - b._.be64.lo;
result._.be64.hi =
a._.be64.hi - b._.be64.hi - (result._.be64.lo > a._.be64.lo);
#endif
return result;
}
CORK_ATTR_UNUSED
static bool
cork_u128_eq(cork_u128 a, cork_u128 b)
{
#if CORK_U128_HAVE_U128
return (a._.u128 == b._.u128);
#else
return (a._.be64.hi == b._.be64.hi) && (a._.be64.lo == b._.be64.lo);
#endif
}
CORK_ATTR_UNUSED
static bool
cork_u128_ne(cork_u128 a, cork_u128 b)
{
#if CORK_U128_HAVE_U128
return (a._.u128 != b._.u128);
#else
return (a._.be64.hi != b._.be64.hi) || (a._.be64.lo != b._.be64.lo);
#endif
}
CORK_ATTR_UNUSED
static bool
cork_u128_lt(cork_u128 a, cork_u128 b)
{
#if CORK_U128_HAVE_U128
return (a._.u128 < b._.u128);
#else
if (a._.be64.hi == b._.be64.hi) {
return a._.be64.lo < b._.be64.lo;
} else {
return a._.be64.hi < b._.be64.hi;
}
#endif
}
CORK_ATTR_UNUSED
static bool
cork_u128_le(cork_u128 a, cork_u128 b)
{
#if CORK_U128_HAVE_U128
return (a._.u128 <= b._.u128);
#else
if (a._.be64.hi == b._.be64.hi) {
return a._.be64.lo <= b._.be64.lo;
} else {
return a._.be64.hi <= b._.be64.hi;
}
#endif
}
CORK_ATTR_UNUSED
static bool
cork_u128_gt(cork_u128 a, cork_u128 b)
{
#if CORK_U128_HAVE_U128
return (a._.u128 > b._.u128);
#else
if (a._.be64.hi == b._.be64.hi) {
return a._.be64.lo > b._.be64.lo;
} else {
return a._.be64.hi > b._.be64.hi;
}
#endif
}
CORK_ATTR_UNUSED
static bool
cork_u128_ge(cork_u128 a, cork_u128 b)
{
#if CORK_U128_HAVE_U128
return (a._.u128 >= b._.u128);
#else
if (a._.be64.hi == b._.be64.hi) {
return a._.be64.lo >= b._.be64.lo;
} else {
return a._.be64.hi >= b._.be64.hi;
}
#endif
}
/* log10(x) = log2(x) / log2(10) ~= log2(x) / 3.322 */
#define CORK_U128_DECIMAL_LENGTH 44 /* ~= 128 / 3 + 1 + 1 */
CORK_API const char *
cork_u128_to_decimal(char *buf, cork_u128 val);
#define CORK_U128_HEX_LENGTH 33
CORK_API const char *
cork_u128_to_hex(char *buf, cork_u128 val);
CORK_API const char *
cork_u128_to_padded_hex(char *buf, cork_u128 val);
#endif /* LIBCORK_CORE_U128_H */
|
281677160/openwrt-package | 3,764 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/core/net-addresses.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011-2013, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CORE_NET_ADDRESSES_H
#define LIBCORK_CORE_NET_ADDRESSES_H
#include <string.h>
#include <libcork/core/api.h>
#include <libcork/core/error.h>
#include <libcork/core/types.h>
/*-----------------------------------------------------------------------
* IP addresses
*/
struct cork_ipv4 {
union {
uint8_t u8[4];
uint16_t u16[2];
uint32_t u32;
} _;
};
struct cork_ipv6 {
union {
uint8_t u8[16];
uint16_t u16[8];
uint32_t u32[4];
uint64_t u64[2];
} _;
};
struct cork_ip {
/* Which version of IP address this is. */
unsigned int version;
union {
struct cork_ipv4 v4;
struct cork_ipv6 v6;
} ip;
};
#define CORK_IPV4_STRING_LENGTH (sizeof "xxx.xxx.xxx.xxx")
#define CORK_IPV6_STRING_LENGTH \
(sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")
#define CORK_IP_STRING_LENGTH CORK_IPV6_STRING_LENGTH
/*** IPv4 ***/
/* src must be well-formed: 4 bytes, big-endian */
#define cork_ipv4_copy(addr, src) \
(memcpy((addr), (src), sizeof(struct cork_ipv4)))
#define cork_ipv4_equal(a1, a2) \
((a1)->_.u32 == (a2)->_.u32)
CORK_API int
cork_ipv4_init(struct cork_ipv4 *addr, const char *str);
CORK_API bool
cork_ipv4_equal_(const struct cork_ipv4 *addr1, const struct cork_ipv4 *addr2);
CORK_API void
cork_ipv4_to_raw_string(const struct cork_ipv4 *addr, char *dest);
CORK_API bool
cork_ipv4_is_valid_network(const struct cork_ipv4 *addr,
unsigned int cidr_prefix);
/*** IPv6 ***/
/* src must be well-formed: 16 bytes, big-endian */
#define cork_ipv6_copy(addr, src) \
(memcpy((addr), (src), sizeof(struct cork_ipv6)))
#define cork_ipv6_equal(a1, a2) \
((a1)->_.u64[0] == (a2)->_.u64[0] && \
(a1)->_.u64[1] == (a2)->_.u64[1])
CORK_API int
cork_ipv6_init(struct cork_ipv6 *addr, const char *str);
CORK_API bool
cork_ipv6_equal_(const struct cork_ipv6 *addr1, const struct cork_ipv6 *addr2);
CORK_API void
cork_ipv6_to_raw_string(const struct cork_ipv6 *addr, char *dest);
CORK_API bool
cork_ipv6_is_valid_network(const struct cork_ipv6 *addr,
unsigned int cidr_prefix);
/*** Generic IP ***/
#define cork_ip_equal(a1, a2) \
((a1)->version == 4? \
((a2)->version == 4 && cork_ipv4_equal(&(a1)->ip.v4, &(a2)->ip.v4)): \
((a2)->version == 6 && cork_ipv6_equal(&(a1)->ip.v6, &(a2)->ip.v6)))
/* src must be well-formed: 4 bytes, big-endian */
#define cork_ip_from_ipv4(addr, src) \
do { \
(addr)->version = 4; \
cork_ipv4_copy(&(addr)->ip.v4, (src)); \
} while (0)
/* src must be well-formed: 16 bytes, big-endian */
#define cork_ip_from_ipv6(addr, src) \
do { \
(addr)->version = 6; \
cork_ipv6_copy(&(addr)->ip.v6, (src)); \
} while (0)
/* src must be well-formed: 4 bytes, big-endian */
CORK_API void
cork_ip_from_ipv4_(struct cork_ip *addr, const void *src);
/* src must be well-formed: 16 bytes, big-endian */
CORK_API void
cork_ip_from_ipv6_(struct cork_ip *addr, const void *src);
CORK_API int
cork_ip_init(struct cork_ip *addr, const char *str);
CORK_API bool
cork_ip_equal_(const struct cork_ip *addr1, const struct cork_ip *addr2);
CORK_API void
cork_ip_to_raw_string(const struct cork_ip *addr, char *dest);
CORK_API bool
cork_ip_is_valid_network(const struct cork_ip *addr, unsigned int cidr_prefix);
#endif /* LIBCORK_CORE_NET_ADDRESSES_H */
|
281677160/openwrt-package | 2,411 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/core/timestamp.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CORE_TIMESTAMP_H
#define LIBCORK_CORE_TIMESTAMP_H
#include <libcork/core/api.h>
#include <libcork/core/error.h>
#include <libcork/core/types.h>
#include <libcork/ds/buffer.h>
typedef uint64_t cork_timestamp;
#define cork_timestamp_init_sec(ts, sec) \
do { \
*(ts) = (((uint64_t) (sec)) << 32); \
} while (0)
#define cork_timestamp_init_gsec(ts, sec, gsec) \
do { \
*(ts) = (((uint64_t) (sec)) << 32) | \
(((uint64_t) (gsec)) & 0xffffffff); \
} while (0)
#define cork_timestamp_init_msec(ts, sec, msec) \
do { \
*(ts) = (((uint64_t) (sec)) << 32) | \
((((uint64_t) (msec)) << 32) / 1000); \
} while (0)
#define cork_timestamp_init_usec(ts, sec, usec) \
do { \
*(ts) = (((uint64_t) (sec)) << 32) | \
((((uint64_t) (usec)) << 32) / 1000000); \
} while (0)
#define cork_timestamp_init_nsec(ts, sec, nsec) \
do { \
*(ts) = (((uint64_t) (sec)) << 32) | \
((((uint64_t) (nsec)) << 32) / 1000000000); \
} while (0)
CORK_API void
cork_timestamp_init_now(cork_timestamp *ts);
#define cork_timestamp_sec(ts) ((uint32_t) ((ts) >> 32))
#define cork_timestamp_gsec(ts) ((uint32_t) ((ts) & 0xffffffff))
CORK_ATTR_UNUSED
static inline uint64_t
cork_timestamp_gsec_to_units(const cork_timestamp ts, uint64_t denom)
{
uint64_t half = ((uint64_t) 1 << 31) / denom;
uint64_t gsec = cork_timestamp_gsec(ts);
gsec += half;
gsec *= denom;
gsec >>= 32;
return gsec;
}
#define cork_timestamp_msec(ts) cork_timestamp_gsec_to_units(ts, 1000)
#define cork_timestamp_usec(ts) cork_timestamp_gsec_to_units(ts, 1000000)
#define cork_timestamp_nsec(ts) cork_timestamp_gsec_to_units(ts, 1000000000)
CORK_API int
cork_timestamp_format_utc(const cork_timestamp ts, const char *format,
struct cork_buffer *dest);
CORK_API int
cork_timestamp_format_local(const cork_timestamp ts, const char *format,
struct cork_buffer *dest);
#endif /* LIBCORK_CORE_TIMESTAMP_H */
|
281677160/openwrt-package | 5,086 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/os/subprocess.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2012-2014, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_OS_SUBPROCESS_H
#define LIBCORK_OS_SUBPROCESS_H
#include <stdarg.h>
#include <libcork/core/api.h>
#include <libcork/core/callbacks.h>
#include <libcork/core/types.h>
#include <libcork/ds/stream.h>
#include <libcork/threads/basics.h>
/*-----------------------------------------------------------------------
* Environments
*/
struct cork_env;
CORK_API struct cork_env *
cork_env_new(void);
CORK_API struct cork_env *
cork_env_clone_current(void);
CORK_API void
cork_env_free(struct cork_env *env);
CORK_API void
cork_env_replace_current(struct cork_env *env);
/* For all of the following, if env is NULL, these functions access or update
* the actual environment of the current process. Otherwise, they act on the
* given environment instance. */
CORK_API const char *
cork_env_get(struct cork_env *env, const char *name);
CORK_API void
cork_env_add(struct cork_env *env, const char *name, const char *value);
CORK_API void
cork_env_add_printf(struct cork_env *env, const char *name,
const char *format, ...)
CORK_ATTR_PRINTF(3,4);
CORK_API void
cork_env_add_vprintf(struct cork_env *env, const char *name,
const char *format, va_list args)
CORK_ATTR_PRINTF(3,0);
CORK_API void
cork_env_remove(struct cork_env *env, const char *name);
/*-----------------------------------------------------------------------
* Executing another process
*/
struct cork_exec;
CORK_API struct cork_exec *
cork_exec_new(const char *program);
CORK_ATTR_SENTINEL
CORK_API struct cork_exec *
cork_exec_new_with_params(const char *program, ...);
CORK_API struct cork_exec *
cork_exec_new_with_param_array(const char *program, char * const *params);
CORK_API void
cork_exec_free(struct cork_exec *exec);
CORK_API const char *
cork_exec_description(struct cork_exec *exec);
CORK_API const char *
cork_exec_program(struct cork_exec *exec);
CORK_API size_t
cork_exec_param_count(struct cork_exec *exec);
CORK_API const char *
cork_exec_param(struct cork_exec *exec, size_t index);
CORK_API void
cork_exec_add_param(struct cork_exec *exec, const char *param);
/* Can return NULL */
CORK_API struct cork_env *
cork_exec_env(struct cork_exec *exec);
/* Takes control of env */
CORK_API void
cork_exec_set_env(struct cork_exec *exec, struct cork_env *env);
/* Can return NULL */
CORK_API const char *
cork_exec_cwd(struct cork_exec *exec);
CORK_API void
cork_exec_set_cwd(struct cork_exec *exec, const char *directory);
CORK_API int
cork_exec_run(struct cork_exec *exec);
/*-----------------------------------------------------------------------
* Subprocesses
*/
struct cork_subprocess;
/* If env is NULL, we use the environment variables of the calling process. */
/* Takes control of body */
CORK_API struct cork_subprocess *
cork_subprocess_new(void *user_data, cork_free_f free_user_data,
cork_run_f run,
struct cork_stream_consumer *stdout_consumer,
struct cork_stream_consumer *stderr_consumer,
int *exit_code);
/* Takes control of exec */
CORK_API struct cork_subprocess *
cork_subprocess_new_exec(struct cork_exec *exec,
struct cork_stream_consumer *stdout_consumer,
struct cork_stream_consumer *stderr_consumer,
int *exit_code);
CORK_API void
cork_subprocess_free(struct cork_subprocess *sub);
CORK_API struct cork_stream_consumer *
cork_subprocess_stdin(struct cork_subprocess *sub);
CORK_API int
cork_subprocess_start(struct cork_subprocess *sub);
CORK_API bool
cork_subprocess_is_finished(struct cork_subprocess *sub);
CORK_API int
cork_subprocess_abort(struct cork_subprocess *sub);
CORK_API bool
cork_subprocess_drain(struct cork_subprocess *sub);
CORK_API int
cork_subprocess_wait(struct cork_subprocess *sub);
/*-----------------------------------------------------------------------
* Groups of subprocesses
*/
struct cork_subprocess_group;
CORK_API struct cork_subprocess_group *
cork_subprocess_group_new(void);
CORK_API void
cork_subprocess_group_free(struct cork_subprocess_group *group);
/* Takes control of sub */
CORK_API void
cork_subprocess_group_add(struct cork_subprocess_group *group,
struct cork_subprocess *sub);
CORK_API int
cork_subprocess_group_start(struct cork_subprocess_group *group);
CORK_API bool
cork_subprocess_group_is_finished(struct cork_subprocess_group *group);
CORK_API int
cork_subprocess_group_abort(struct cork_subprocess_group *group);
CORK_API bool
cork_subprocess_group_drain(struct cork_subprocess_group *group);
CORK_API int
cork_subprocess_group_wait(struct cork_subprocess_group *group);
#endif /* LIBCORK_OS_SUBPROCESS_H */
|
281677160/openwrt-package | 7,015 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/os/files.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2012-2013, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_CORE_FILES_H
#define LIBCORK_CORE_FILES_H
#include <libcork/core/api.h>
#include <libcork/core/types.h>
/*-----------------------------------------------------------------------
* Paths
*/
struct cork_path;
/* path can be relative or absolute */
CORK_API struct cork_path *
cork_path_new(const char *path);
CORK_API struct cork_path *
cork_path_clone(const struct cork_path *other);
CORK_API void
cork_path_free(struct cork_path *path);
CORK_API void
cork_path_set(struct cork_path *path, const char *content);
CORK_API const char *
cork_path_get(const struct cork_path *path);
CORK_API int
cork_path_set_cwd(struct cork_path *path);
CORK_API struct cork_path *
cork_path_cwd(void);
CORK_API int
cork_path_set_absolute(struct cork_path *path);
CORK_API struct cork_path *
cork_path_absolute(const struct cork_path *other);
CORK_API void
cork_path_append(struct cork_path *path, const char *more);
CORK_API void
cork_path_append_path(struct cork_path *path, const struct cork_path *more);
CORK_API struct cork_path *
cork_path_join(const struct cork_path *other, const char *more);
CORK_API struct cork_path *
cork_path_join_path(const struct cork_path *other,
const struct cork_path *more);
CORK_API void
cork_path_set_basename(struct cork_path *path);
CORK_API struct cork_path *
cork_path_basename(const struct cork_path *other);
CORK_API void
cork_path_set_dirname(struct cork_path *path);
CORK_API struct cork_path *
cork_path_dirname(const struct cork_path *other);
/*-----------------------------------------------------------------------
* Lists of paths
*/
struct cork_path_list;
CORK_API struct cork_path_list *
cork_path_list_new_empty(void);
/* list must be a colon-separated list of paths */
CORK_API struct cork_path_list *
cork_path_list_new(const char *list);
CORK_API void
cork_path_list_free(struct cork_path_list *list);
CORK_API const char *
cork_path_list_to_string(const struct cork_path_list *list);
/* Takes control of path. path must not already be in the list. */
CORK_API void
cork_path_list_add(struct cork_path_list *list, struct cork_path *path);
CORK_API size_t
cork_path_list_size(const struct cork_path_list *list);
/* The list still owns path; you must not free it or modify it. */
CORK_API const struct cork_path *
cork_path_list_get(const struct cork_path_list *list, size_t index);
/*-----------------------------------------------------------------------
* Files
*/
#define CORK_FILE_RECURSIVE 0x0001
#define CORK_FILE_PERMISSIVE 0x0002
typedef unsigned int cork_file_mode;
enum cork_file_type {
CORK_FILE_MISSING = 0,
CORK_FILE_REGULAR = 1,
CORK_FILE_DIRECTORY = 2,
CORK_FILE_SYMLINK = 3,
CORK_FILE_UNKNOWN = 4
};
struct cork_file;
CORK_API struct cork_file *
cork_file_new(const char *path);
/* Takes control of path */
CORK_API struct cork_file *
cork_file_new_from_path(struct cork_path *path);
CORK_API void
cork_file_free(struct cork_file *file);
/* File owns the result; you should not free it */
CORK_API const struct cork_path *
cork_file_path(struct cork_file *file);
CORK_API int
cork_file_exists(struct cork_file *file, bool *exists);
CORK_API int
cork_file_type(struct cork_file *file, enum cork_file_type *type);
typedef int
(*cork_file_directory_iterator)(struct cork_file *child, const char *rel_name,
void *user_data);
CORK_API int
cork_file_iterate_directory(struct cork_file *file,
cork_file_directory_iterator iterator,
void *user_data);
/* If flags includes CORK_FILE_RECURSIVE, this creates parent directories,
* if needed. If flags doesn't include CORK_FILE_PERMISSIVE, then it's an error
* if the directory already exists. */
CORK_API int
cork_file_mkdir(struct cork_file *file, cork_file_mode mode,
unsigned int flags);
/* Removes a file or directory. If file is a directory, and flags contains
* CORK_FILE_RECURSIVE, then all of the directory's contents are removed, too.
* Otherwise, the directory must already be empty. */
CORK_API int
cork_file_remove(struct cork_file *file, unsigned int flags);
CORK_API struct cork_file *
cork_path_list_find_file(const struct cork_path_list *list,
const char *rel_path);
/*-----------------------------------------------------------------------
* Lists of files
*/
struct cork_file_list;
CORK_API struct cork_file_list *
cork_file_list_new_empty(void);
CORK_API struct cork_file_list *
cork_file_list_new(struct cork_path_list *path_list);
CORK_API void
cork_file_list_free(struct cork_file_list *list);
/* Takes control of file. file must not already be in the list. */
CORK_API void
cork_file_list_add(struct cork_file_list *list, struct cork_file *file);
CORK_API size_t
cork_file_list_size(struct cork_file_list *list);
/* The list still owns file; you must not free it. Editing the file updates the
* entry in the list. */
CORK_API struct cork_file *
cork_file_list_get(struct cork_file_list *list, size_t index);
CORK_API struct cork_file_list *
cork_path_list_find_files(const struct cork_path_list *list,
const char *rel_path);
/*-----------------------------------------------------------------------
* Walking a directory tree
*/
#define CORK_SKIP_DIRECTORY 1
struct cork_dir_walker {
int
(*enter_directory)(struct cork_dir_walker *walker, const char *full_path,
const char *rel_path, const char *base_name);
int
(*file)(struct cork_dir_walker *walker, const char *full_path,
const char *rel_path, const char *base_name);
int
(*leave_directory)(struct cork_dir_walker *walker, const char *full_path,
const char *rel_path, const char *base_name);
};
#define cork_dir_walker_enter_directory(w, fp, rp, bn) \
((w)->enter_directory((w), (fp), (rp), (bn)))
#define cork_dir_walker_file(w, fp, rp, bn) \
((w)->file((w), (fp), (rp), (bn)))
#define cork_dir_walker_leave_directory(w, fp, rp, bn) \
((w)->leave_directory((w), (fp), (rp), (bn)))
CORK_API int
cork_walk_directory(const char *path, struct cork_dir_walker *walker);
/*-----------------------------------------------------------------------
* Standard paths and path lists
*/
CORK_API struct cork_path *
cork_path_home(void);
CORK_API struct cork_path_list *
cork_path_config_paths(void);
CORK_API struct cork_path_list *
cork_path_data_paths(void);
CORK_API struct cork_path *
cork_path_user_cache_path(void);
CORK_API struct cork_path *
cork_path_user_runtime_path(void);
#endif /* LIBCORK_CORE_FILES_H */
|
281677160/openwrt-package | 3,713 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/helpers/errors.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_HELPERS_ERRORS_H
#define LIBCORK_HELPERS_ERRORS_H
/* This header is *not* automatically included when you include
* libcork/core.h, since we define some macros that don't include a
* cork_ or CORK_ prefix. Don't want to pollute your namespace unless
* you ask for it! */
#include <libcork/core/allocator.h>
#include <libcork/core/attributes.h>
#include <libcork/core/error.h>
#if !defined(CORK_PRINT_ERRORS)
#define CORK_PRINT_ERRORS 0
#endif
#if !defined(CORK_PRINT_ERROR)
#if CORK_PRINT_ERRORS
#include <stdio.h>
#define CORK_PRINT_ERROR_(func, file, line) \
fprintf(stderr, "---\nError in %s (%s:%u)\n %s\n", \
(func), (file), (unsigned int) (line), \
cork_error_message());
#define CORK_PRINT_ERROR() CORK_PRINT_ERROR_(__func__, __FILE__, __LINE__)
#else
#define CORK_PRINT_ERROR() /* do nothing */
#endif
#endif
/* A bunch of macros for calling a function that returns an error. If
* an error occurs, it will automatically be propagated out as the
* result of your own function. With these macros, you won't have a
* check to check or modify the error condition; it's returned as-is.
*
* XZ_check
*
* where:
*
* X = what happens if an error occurs
* "e" = jump to the "error" label
* "rY" = return a default error result (Y defined below)
* "x" = return an error result that you specify
*
* Y = your return type
* "i" = int
* "p" = some pointer type
*
* Z = the return type of the function you're calling
* "e" = use cork_error_occurred() to check
* "i" = int
* "p" = some pointer type
*
* In all cases, we assume that your function has a cork_error parameter
* called "err".
*/
/* jump to "error" label */
#define ee_check(call) \
do { \
(call); \
if (CORK_UNLIKELY(cork_error_occurred())) { \
CORK_PRINT_ERROR(); \
goto error; \
} \
} while (0)
#define ei_check(call) \
do { \
int __rc = (call); \
if (CORK_UNLIKELY(__rc != 0)) { \
CORK_PRINT_ERROR(); \
goto error; \
} \
} while (0)
#define ep_check(call) \
do { \
const void *__result = (call); \
if (CORK_UNLIKELY(__result == NULL)) { \
CORK_PRINT_ERROR(); \
goto error; \
} \
} while (0)
/* return specific error code */
#define xe_check(result, call) \
do { \
(call); \
if (CORK_UNLIKELY(cork_error_occurred())) { \
CORK_PRINT_ERROR(); \
return result; \
} \
} while (0)
#define xi_check(result, call) \
do { \
int __rc = (call); \
if (CORK_UNLIKELY(__rc != 0)) { \
CORK_PRINT_ERROR(); \
return result; \
} \
} while (0)
#define xp_check(result, call) \
do { \
const void *__result = (call); \
if (CORK_UNLIKELY(__result == NULL)) { \
CORK_PRINT_ERROR(); \
return result; \
} \
} while (0)
/* return default error code */
#define rie_check(call) xe_check(-1, call)
#define rii_check(call) xi_check(__rc, call)
#define rip_check(call) xp_check(-1, call)
#define rpe_check(call) xe_check(NULL, call)
#define rpi_check(call) xi_check(NULL, call)
#define rpp_check(call) xp_check(NULL, call)
#endif /* LIBCORK_HELPERS_ERRORS_H */
|
281677160/openwrt-package | 2,515 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/helpers/posix.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2013, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_HELPERS_POSIX_H
#define LIBCORK_HELPERS_POSIX_H
/* This header is *not* automatically included when you include
* libcork/core.h, since we define some macros that don't include a
* cork_ or CORK_ prefix. Don't want to pollute your namespace unless
* you ask for it! */
#include <errno.h>
#include <libcork/core/allocator.h>
#include <libcork/core/attributes.h>
#include <libcork/core/error.h>
#if !defined(CORK_PRINT_ERRORS)
#define CORK_PRINT_ERRORS 0
#endif
#if !defined(CORK_PRINT_ERROR)
#if CORK_PRINT_ERRORS
#include <stdio.h>
#define CORK_PRINT_ERROR_(func, file, line) \
fprintf(stderr, "---\nError in %s (%s:%u)\n %s\n", \
(func), (file), (unsigned int) (line), \
cork_error_message());
#define CORK_PRINT_ERROR() CORK_PRINT_ERROR_(__func__, __FILE__, __LINE__)
#else
#define CORK_PRINT_ERROR() /* do nothing */
#endif
#endif
#define xi_check_posix(call, on_error) \
do { \
while (true) { \
if ((call) == -1) { \
if (errno == EINTR) { \
continue; \
} else { \
cork_system_error_set(); \
CORK_PRINT_ERROR(); \
on_error; \
} \
} else { \
break; \
} \
} \
} while (0)
#define xp_check_posix(call, on_error) \
do { \
while (true) { \
if ((call) == NULL) { \
if (errno == EINTR) { \
continue; \
} else { \
cork_system_error_set(); \
CORK_PRINT_ERROR(); \
on_error; \
} \
} else { \
break; \
} \
} \
} while (0)
#define ei_check_posix(call) xi_check_posix(call, goto error)
#define rii_check_posix(call) xi_check_posix(call, return -1)
#define rpi_check_posix(call) xi_check_posix(call, return NULL)
#define ep_check_posix(call) xp_check_posix(call, goto error)
#define rip_check_posix(call) xp_check_posix(call, return -1)
#define rpp_check_posix(call) xp_check_posix(call, return NULL)
#endif /* LIBCORK_HELPERS_POSIX_H */
|
281677160/openwrt-package | 1,133 | luci-app-ssr-plus/shadowsocksr-libev/src/libcork/include/libcork/helpers/gc.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2011-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the COPYING file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef LIBCORK_HELPERS_REFCOUNT_H
#define LIBCORK_HELPERS_REFCOUNT_H
#include <libcork/core/gc.h>
#include <libcork/core/types.h>
#define _free_(name) \
static void \
name##__free(void *obj)
#define _recurse_(name) \
static void \
name##__recurse(struct cork_gc *gc, void *obj, \
cork_gc_recurser recurse, void *ud)
#define _gc_(name) \
static struct cork_gc_obj_iface name##__gc = { \
name##__free, name##__recurse \
};
#define _gc_no_free_(name) \
static struct cork_gc_obj_iface name##__gc = { \
NULL, name##__recurse \
};
#define _gc_no_recurse_(name) \
static struct cork_gc_obj_iface name##__gc = { \
name##__free, NULL \
};
#define _gc_leaf_(name) \
static struct cork_gc_obj_iface name##__gc = { \
NULL, NULL \
};
#endif /* LIBCORK_HELPERS_REFCOUNT_H */
|
281677160/openwrt-package | 1,729 | luci-app-ssr-plus/shadowsocksr-libev/src/libev/cmake/configure.cmake | # Platform checks
include ( CheckFunctionExists )
include ( CheckIncludeFiles )
check_include_files ( dlfcn.h HAVE_DLFCN_H )
check_include_files ( inttypes.h HAVE_INTTYPES_H )
check_include_files ( memory.h HAVE_MEMORY_H )
check_include_files ( poll.h HAVE_POLL_H )
check_include_files ( port.h HAVE_PORT_H )
check_include_files ( stdint.h HAVE_STDINT_H )
check_include_files ( stdlib.h HAVE_STDLIB_H )
check_include_files ( strings.h HAVE_STRINGS_H )
check_include_files ( string.h HAVE_STRING_H )
check_include_files ( "sys/epoll.h" HAVE_SYS_EPOLL_H )
check_include_files ( "sys/eventfd.h" HAVE_SYS_EVENTFD_H )
check_include_files ( "sys/event.h" HAVE_SYS_EVENT_H )
check_include_files ( "sys/inotify.h" HAVE_SYS_INOTIFY_H )
check_include_files ( "sys/select.h" HAVE_SYS_SELECT_H )
check_include_files ( "sys/signalfd.h" HAVE_SYS_SIGNALFD_H )
check_include_files ( "sys/stat.h" HAVE_SYS_STAT_H )
check_include_files ( "sys/types.h" HAVE_SYS_TYPES_H )
check_include_files ( "sys/syscall.h" HAVE_SYS_CALL_H )
check_include_files ( unistd.h HAVE_UNISTD_H )
check_function_exists ( clock_gettime HAVE_CLOCK_GETTIME )
check_function_exists ( epoll_ctl HAVE_EPOLL_CTL )
check_function_exists ( eventfd HAVE_EVENTFD )
check_function_exists ( floor HAVE_FLOOR )
check_function_exists ( inotify_init HAVE_INOTIFY_INIT )
check_function_exists ( kqueue HAVE_KQUEUE )
check_function_exists ( nanosleep HAVE_NANOSLEEP )
check_function_exists ( poll HAVE_POLL )
check_function_exists ( port_create HAVE_PORT_CREATE )
check_function_exists ( select HAVE_SELECT )
check_function_exists ( signalfd HAVE_SIGNALFD )
find_library ( HAVE_LIBRT rt )
# Tweaks
if (${HAVE_SYS_CALL_H})
set(HAVE_CLOCK_SYSCALL ${HAVE_CLOCK_GETTIME})
endif ()
|
281677160/openwrt-package | 2,542 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/set/storage.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2010-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libcork/core.h>
#include "ipset/bdd/nodes.h"
#include "ipset/errors.h"
#include "ipset/ipset.h"
static void
create_errno_error(FILE *stream)
{
if (ferror(stream)) {
cork_error_set(IPSET_ERROR, IPSET_IO_ERROR, "%s", strerror(errno));
} else {
cork_unknown_error();
}
}
struct file_consumer {
/* file_consumer is a subclass of cork_stream_consumer */
struct cork_stream_consumer parent;
/* the file to write the data into */
FILE *fp;
};
static int
file_consumer_data(struct cork_stream_consumer *vself,
const void *buf, size_t size, bool is_first)
{
struct file_consumer *self =
cork_container_of(vself, struct file_consumer, parent);
size_t bytes_written = fwrite(buf, 1, size, self->fp);
/* If there was an error writing to the file, then signal this to
* the producer */
if (bytes_written == size) {
return 0;
} else {
create_errno_error(self->fp);
return -1;
}
}
static int
file_consumer_eof(struct cork_stream_consumer *vself)
{
/* We don't close the file, so there's nothing special to do at
* end-of-stream. */
return 0;
}
int
ipset_save_to_stream(struct cork_stream_consumer *stream,
const struct ip_set *set)
{
return ipset_node_cache_save(stream, set->cache, set->set_bdd);
}
int
ipset_save(FILE *fp, const struct ip_set *set)
{
struct file_consumer stream = {
{ file_consumer_data, file_consumer_eof, NULL }, fp
};
return ipset_save_to_stream(&stream.parent, set);
}
int
ipset_save_dot(FILE *fp, const struct ip_set *set)
{
struct file_consumer stream = {
{ file_consumer_data, file_consumer_eof, NULL }, fp
};
return ipset_node_cache_save_dot(&stream.parent, set->cache, set->set_bdd);
}
struct ip_set *
ipset_load(FILE *stream)
{
struct ip_set *set;
ipset_node_id new_bdd;
set = ipset_new();
new_bdd = ipset_node_cache_load(stream, set->cache);
if (cork_error_occurred()) {
ipset_free(set);
return NULL;
}
set->set_bdd = new_bdd;
return set;
}
|
281677160/openwrt-package | 10,326 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/set/iterator.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2010-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#include <string.h>
#include <libcork/core.h>
#include "ipset/bdd/nodes.h"
#include "ipset/bits.h"
#include "ipset/ipset.h"
#include "ipset/logging.h"
#define IPV4_BIT_SIZE 32
#define IPV6_BIT_SIZE 128
/* Forward declarations */
static void
process_assignment(struct ipset_iterator *iterator);
static void
expand_ipv6(struct ipset_iterator *iterator);
/**
* Find the highest non-EITHER bit in an assignment, starting from the
* given bit index.
*/
static unsigned int
find_last_non_either_bit(struct ipset_assignment *assignment,
unsigned int starting_bit)
{
unsigned int i;
for (i = starting_bit; i >= 1; i--) {
enum ipset_tribool value = ipset_assignment_get(assignment, i);
if (value != IPSET_EITHER) {
return i;
}
}
return 0;
}
/**
* Create a generic IP address object from the current expanded
* assignment.
*/
static void
create_ip_address(struct ipset_iterator *iterator)
{
struct cork_ip *addr = &iterator->addr;
struct ipset_expanded_assignment *exp = iterator->assignment_iterator;
/* Initialize the address to all 0 bits. */
memset(addr, 0, sizeof(struct cork_ip));
/* Check variable 0 to see if this is an IPv4 or IPv6 address. */
addr->version = IPSET_BIT_GET(exp->values.buf, 0)? 4: 6;
/* Copy bits from the expanded assignment. The number of bits to
* copy is given as the current netmask. We'll have calculated that
* already based on the non-expanded assignment. */
unsigned int i;
for (i = 0; i < iterator->cidr_prefix; i++) {
IPSET_BIT_SET(&addr->ip, i, IPSET_BIT_GET(exp->values.buf, i+1));
}
#if IPSET_DEBUG
char buf[CORK_IP_STRING_LENGTH];
cork_ip_to_raw_string(addr, buf);
DEBUG("Current IP address is %s/%u", buf, iterator->cidr_prefix);
#endif
}
/**
* Advance the BDD iterator, taking into account that some assignments
* need to be expanded twice.
*/
static void
advance_assignment(struct ipset_iterator *iterator)
{
/* Check the current state of the iterator to determine how to
* advance. */
/* In most cases, the assignment we just finished only needed to be
* expanded once. So we move on to the next assignment and process
* it. */
if (CORK_LIKELY(iterator->multiple_expansion_state ==
IPSET_ITERATOR_NORMAL))
{
ipset_bdd_iterator_advance(iterator->bdd_iterator);
process_assignment(iterator);
return;
}
/* If the assignment needs to be expanded twice, we'll do the IPv4
* expansion first. If that's what we've just finished, do the IPv6
* expansion next. */
if (iterator->multiple_expansion_state == IPSET_ITERATOR_MULTIPLE_IPV4) {
DEBUG("Expanding IPv6 second");
iterator->multiple_expansion_state = IPSET_ITERATOR_MULTIPLE_IPV6;
ipset_assignment_set
(iterator->bdd_iterator->assignment, 0, IPSET_FALSE);
expand_ipv6(iterator);
return;
}
/* If we've just finished the IPv6 expansion, then we've finished
* with this assignment. Before moving on to the next one, we have
* to reset variable 0 to EITHER (which it was before we started
* this whole mess). */
if (iterator->multiple_expansion_state == IPSET_ITERATOR_MULTIPLE_IPV6) {
DEBUG("Finished both expansions");
ipset_assignment_set
(iterator->bdd_iterator->assignment, 0, IPSET_EITHER);
ipset_bdd_iterator_advance(iterator->bdd_iterator);
process_assignment(iterator);
return;
}
}
/**
* Process the current expanded assignment in the current BDD
* assignment.
*/
static void
process_expanded_assignment(struct ipset_iterator *iterator)
{
if (iterator->assignment_iterator->finished) {
/* If there isn't anything in the expanded assignment, advance
* to the next BDD assignment. */
DEBUG("Expanded assignment is finished");
ipset_expanded_assignment_free(iterator->assignment_iterator);
iterator->assignment_iterator = NULL;
advance_assignment(iterator);
} else {
/* Otherwise, we've found a fully expanded assignment, so create
* an IP address for it and return. */
create_ip_address(iterator);
}
}
/**
* Expand the current assignment as IPv4 addresses.
*/
static void
expand_ipv4(struct ipset_iterator *iterator)
{
unsigned int last_bit;
if (iterator->summarize) {
last_bit = find_last_non_either_bit
(iterator->bdd_iterator->assignment, IPV4_BIT_SIZE);
DEBUG("Last non-either bit is %u", last_bit);
} else {
last_bit = IPV4_BIT_SIZE;
}
iterator->assignment_iterator =
ipset_assignment_expand
(iterator->bdd_iterator->assignment, last_bit + 1);
iterator->cidr_prefix = last_bit;
process_expanded_assignment(iterator);
}
/**
* Expand the current assignment as IPv4 addresses.
*/
static void
expand_ipv6(struct ipset_iterator *iterator)
{
unsigned int last_bit;
if (iterator->summarize) {
last_bit = find_last_non_either_bit
(iterator->bdd_iterator->assignment, IPV6_BIT_SIZE);
DEBUG("Last non-either bit is %u", last_bit);
} else {
last_bit = IPV6_BIT_SIZE;
}
iterator->assignment_iterator =
ipset_assignment_expand
(iterator->bdd_iterator->assignment, last_bit + 1);
iterator->cidr_prefix = last_bit;
process_expanded_assignment(iterator);
}
/**
* Process the current assignment in the BDD iterator.
*/
static void
process_assignment(struct ipset_iterator *iterator)
{
while (!iterator->bdd_iterator->finished) {
if (iterator->bdd_iterator->value == iterator->desired_value) {
/* If the BDD iterator hasn't finished, and the result of
* the function with this assignment matches what the caller
* wants, then we've found an assignment to generate IP
* addresses from.
*
* Try to expand this assignment, and process the first
* expanded assignment. We want 32 + 1 variables if the
* current address is IPv4; 128 + 1 if it's IPv6. */
DEBUG("Got a matching BDD assignment");
enum ipset_tribool address_type = ipset_assignment_get
(iterator->bdd_iterator->assignment, 0);
if (address_type == IPSET_FALSE) {
/* FALSE means IPv6*/
DEBUG("Assignment is IPv6");
iterator->multiple_expansion_state = IPSET_ITERATOR_NORMAL;
expand_ipv6(iterator);
return;
} else if (address_type == IPSET_TRUE) {
/* TRUE means IPv4*/
DEBUG("Assignment is IPv4");
iterator->multiple_expansion_state = IPSET_ITERATOR_NORMAL;
expand_ipv4(iterator);
return;
} else {
/* EITHER means that this assignment contains both IPv4
* and IPv6 addresses. Expand it as IPv4 first. */
DEBUG("Assignment is both IPv4 and IPv6");
DEBUG("Expanding IPv4 first");
iterator->multiple_expansion_state =
IPSET_ITERATOR_MULTIPLE_IPV4;
ipset_assignment_set
(iterator->bdd_iterator->assignment, 0, IPSET_TRUE);
expand_ipv4(iterator);
return;
}
}
/* The BDD iterator has a value, but it doesn't match the one we
* want. Advance the BDD iterator and try again. */
DEBUG("Value is %d, skipping", iterator->bdd_iterator->value);
ipset_bdd_iterator_advance(iterator->bdd_iterator);
}
/* If we fall through, then the BDD iterator has finished. That
* means there's nothing left for the set iterator. */
DEBUG("Set iterator is finished");
ipset_expanded_assignment_free(iterator->assignment_iterator);
iterator->assignment_iterator = NULL;
ipset_bdd_iterator_free(iterator->bdd_iterator);
iterator->bdd_iterator = NULL;
iterator->finished = true;
}
static struct ipset_iterator *
create_iterator(struct ip_set *set, bool desired_value, bool summarize)
{
/* First allocate the iterator itself. */
struct ipset_iterator *iterator = cork_new(struct ipset_iterator);
iterator->finished = false;
iterator->assignment_iterator = NULL;
iterator->desired_value = desired_value;
iterator->summarize = summarize;
/* Then create the iterator that returns each BDD assignment. */
DEBUG("Iterating set");
iterator->bdd_iterator = ipset_node_iterate(set->cache, set->set_bdd);
/* Then drill down from the current BDD assignment, creating an
* expanded assignment for it. */
process_assignment(iterator);
return iterator;
}
struct ipset_iterator *
ipset_iterate(struct ip_set *set, bool desired_value)
{
return create_iterator(set, desired_value, false);
}
struct ipset_iterator *
ipset_iterate_networks(struct ip_set *set, bool desired_value)
{
return create_iterator(set, desired_value, true);
}
void
ipset_iterator_free(struct ipset_iterator *iterator)
{
if (iterator->bdd_iterator != NULL) {
ipset_bdd_iterator_free(iterator->bdd_iterator);
}
if (iterator->assignment_iterator != NULL) {
ipset_expanded_assignment_free(iterator->assignment_iterator);
}
free(iterator);
}
void
ipset_iterator_advance(struct ipset_iterator *iterator)
{
/* If we're already at the end of the iterator, don't do anything. */
if (CORK_UNLIKELY(iterator->finished)) {
return;
}
/* Otherwise, advance the expanded assignment iterator to the next
* assignment, and then drill down into it. */
DEBUG("Advancing set iterator");
ipset_expanded_assignment_advance(iterator->assignment_iterator);
process_expanded_assignment(iterator);
}
|
281677160/openwrt-package | 2,202 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/set/inspection.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2009-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#include <libcork/core.h>
#include "ipset/bdd/nodes.h"
#include "ipset/ipset.h"
bool
ipset_is_empty(const struct ip_set *set)
{
/* Since BDDs are unique, the only empty set is the “false” BDD. */
return (set->set_bdd == ipset_terminal_node_id(false));
}
bool
ipset_is_equal(const struct ip_set *set1, const struct ip_set *set2)
{
return ipset_node_cache_nodes_equal
(set1->cache, set1->set_bdd, set2->cache, set2->set_bdd);
}
size_t
ipset_memory_size(const struct ip_set *set)
{
return ipset_node_memory_size(set->cache, set->set_bdd);
}
bool
ipset_ip_add(struct ip_set *set, struct cork_ip *addr)
{
if (addr->version == 4) {
return ipset_ipv4_add(set, &addr->ip.v4);
} else {
return ipset_ipv6_add(set, &addr->ip.v6);
}
}
bool
ipset_ip_add_network(struct ip_set *set, struct cork_ip *addr,
unsigned int cidr_prefix)
{
if (addr->version == 4) {
return ipset_ipv4_add_network(set, &addr->ip.v4, cidr_prefix);
} else {
return ipset_ipv6_add_network(set, &addr->ip.v6, cidr_prefix);
}
}
bool
ipset_ip_remove(struct ip_set *set, struct cork_ip *addr)
{
if (addr->version == 4) {
return ipset_ipv4_remove(set, &addr->ip.v4);
} else {
return ipset_ipv6_remove(set, &addr->ip.v6);
}
}
bool
ipset_ip_remove_network(struct ip_set *set, struct cork_ip *addr,
unsigned int cidr_prefix)
{
if (addr->version == 4) {
return ipset_ipv4_remove_network(set, &addr->ip.v4, cidr_prefix);
} else {
return ipset_ipv6_remove_network(set, &addr->ip.v6, cidr_prefix);
}
}
bool
ipset_contains_ip(const struct ip_set *set, struct cork_ip *addr)
{
if (addr->version == 4) {
return ipset_contains_ipv4(set, &addr->ip.v4);
} else {
return ipset_contains_ipv6(set, &addr->ip.v6);
}
}
|
281677160/openwrt-package | 1,257 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/set/ipv6_set.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2009-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
/*
* The IPv4 and IPv6 set types are basically identical, except for the
* names of the functions, and the size of the values that are being
* stored. Rather than having two mostly duplicate definitions of
* each function, we define “template functions” where anything that
* depends on the size of the IP address is defined using the
* following macros.
*/
/* The name of the cork_ipvX type. */
#define CORK_IP struct cork_ipv6
/* The number of bits in an IPvX address. */
#define IP_BIT_SIZE 128
/* The value of the discriminator variable for an IPvX address. */
#define IP_DISCRIMINATOR_VALUE false
/* Creates a identifier of the form “ipset_ipv6_<basename>”. */
#define IPSET_NAME(basename) ipset_ipv6_##basename
/* Creates a identifier of the form “ipset_<basename>_ipv6”. */
#define IPSET_PRENAME(basename) ipset_##basename##_ipv6
/* Now include all of the templates. */
#include "inspection-template.c.in"
|
281677160/openwrt-package | 1,252 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/set/ipv4_set.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2009-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
/*
* The IPv4 and IPv6 set types are basically identical, except for the
* names of the functions, and the size of the values that are being
* stored. Rather than having two mostly duplicate definitions of each
* function, we define “template functions” where anything that depends
* on the size of the IP address is defined using the following macros.
*/
/* The name of the cork_ipvX type. */
#define CORK_IP struct cork_ipv4
/* The number of bits in an IPvX address. */
#define IP_BIT_SIZE 32
/* The value of the discriminator variable for an IPvX address. */
#define IP_DISCRIMINATOR_VALUE true
/* Creates a identifier of the form “ipset_ipv4_<basename>”. */
#define IPSET_NAME(basename) ipset_ipv4_##basename
/* Creates a identifier of the form “ipset_<basename>_ipv4”. */
#define IPSET_PRENAME(basename) ipset_##basename##_ipv4
/* Now include all of the templates. */
#include "inspection-template.c.in"
|
281677160/openwrt-package | 1,069 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/map/allocation.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2009-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#include <libcork/core.h>
#include "ipset/bdd/nodes.h"
#include "ipset/ipset.h"
void
ipmap_init(struct ip_map *map, int default_value)
{
/* The map starts empty, so every value assignment should yield the
* default. */
map->cache = ipset_node_cache_new();
map->default_bdd = ipset_terminal_node_id(default_value);
map->map_bdd = map->default_bdd;
}
struct ip_map *
ipmap_new(int default_value)
{
struct ip_map *result = cork_new(struct ip_map);
ipmap_init(result, default_value);
return result;
}
void
ipmap_done(struct ip_map *map)
{
ipset_node_decref(map->cache, map->map_bdd);
ipset_node_cache_free(map->cache);
}
void
ipmap_free(struct ip_map *map)
{
ipmap_done(map);
free(map);
}
|
281677160/openwrt-package | 2,454 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/map/storage.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2009-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libcork/core.h>
#include "ipset/bdd/nodes.h"
#include "ipset/errors.h"
#include "ipset/ipset.h"
static void
create_errno_error(FILE *stream)
{
if (ferror(stream)) {
cork_error_set(IPSET_ERROR, IPSET_IO_ERROR, "%s", strerror(errno));
} else {
cork_unknown_error();
}
}
struct file_consumer {
/* file_consumer is a subclass of cork_stream_consumer */
struct cork_stream_consumer parent;
/* the file to write the data into */
FILE *fp;
};
static int
file_consumer_data(struct cork_stream_consumer *vself,
const void *buf, size_t size, bool is_first)
{
struct file_consumer *self =
cork_container_of(vself, struct file_consumer, parent);
size_t bytes_written = fwrite(buf, 1, size, self->fp);
/* If there was an error writing to the file, then signal this to
* the producer */
if (bytes_written == size) {
return 0;
} else {
create_errno_error(self->fp);
return -1;
}
}
static int
file_consumer_eof(struct cork_stream_consumer *vself)
{
/* We don't close the file, so there's nothing special to do at
* end-of-stream. */
return 0;
}
int
ipmap_save_to_stream(struct cork_stream_consumer *stream,
const struct ip_map *map)
{
return ipset_node_cache_save(stream, map->cache, map->map_bdd);
}
int
ipmap_save(FILE *fp, const struct ip_map *map)
{
struct file_consumer stream = {
{ file_consumer_data, file_consumer_eof, NULL }, fp
};
return ipmap_save_to_stream(&stream.parent, map);
}
struct ip_map *
ipmap_load(FILE *stream)
{
struct ip_map *map;
ipset_node_id new_bdd;
/* It doesn't matter what default value we use here, because we're
* going to replace it with the default BDD we load in from the
* file. */
map = ipmap_new(0);
new_bdd = ipset_node_cache_load(stream, map->cache);
if (cork_error_occurred()) {
ipmap_free(map);
return NULL;
}
map->map_bdd = new_bdd;
return map;
}
|
281677160/openwrt-package | 1,247 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/map/ipv4_map.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2009-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
/*
* The IPv4 and IPv6 map types are basically identical, except for the
* names of the functions, and the size of the values that are being
* stored. Rather than having two mostly duplicate definitions of each
* function, we define “template functions” where anything that depends
* on the size of the IP address is defined using the following macros.
*/
/* The name of the cork_ipvX type. */
#define CORK_IP struct cork_ipv4
/* The number of bits in an IPvX address. */
#define IP_BIT_SIZE 32
/* The value of the discriminator variable for an IPvX address. */
#define IP_DISCRIMINATOR_VALUE true
/* Creates a identifier of the form “ipset_ipv4_<basename>”. */
#define IPSET_NAME(basename) ipset_ipv4_##basename
/* Creates a identifier of the form “ipmap_ipv4_<basename>”. */
#define IPMAP_NAME(basename) ipmap_ipv4_##basename
/* Now include all of the templates. */
#include "inspection-template.c.in"
|
281677160/openwrt-package | 1,674 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/map/inspection.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2009-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#include <libcork/core.h>
#include "ipset/bdd/nodes.h"
#include "ipset/ipset.h"
bool
ipmap_is_empty(const struct ip_map *map)
{
/* Since BDDs are unique, any map that maps all addresses to the
* default value is “empty”. */
return (map->map_bdd == map->default_bdd);
}
bool
ipmap_is_equal(const struct ip_map *map1, const struct ip_map *map2)
{
return ipset_node_cache_nodes_equal
(map1->cache, map1->map_bdd, map2->cache, map2->map_bdd);
}
size_t
ipmap_memory_size(const struct ip_map *map)
{
return ipset_node_memory_size(map->cache, map->map_bdd);
}
void
ipmap_ip_set(struct ip_map *map, struct cork_ip *addr, int value)
{
if (addr->version == 4) {
ipmap_ipv4_set(map, &addr->ip.v4, value);
} else {
ipmap_ipv6_set(map, &addr->ip.v6, value);
}
}
void
ipmap_ip_set_network(struct ip_map *map, struct cork_ip *addr,
unsigned int cidr_prefix, int value)
{
if (addr->version == 4) {
ipmap_ipv4_set_network(map, &addr->ip.v4, cidr_prefix, value);
} else {
ipmap_ipv6_set_network(map, &addr->ip.v6, cidr_prefix, value);
}
}
int
ipmap_ip_get(struct ip_map *map, struct cork_ip *addr)
{
if (addr->version == 4) {
return ipmap_ipv4_get(map, &addr->ip.v4);
} else {
return ipmap_ipv6_get(map, &addr->ip.v6);
}
}
|
281677160/openwrt-package | 1,249 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/map/ipv6_map.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2009-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
/*
* The IPv4 and IPv6 map types are basically identical, except for the
* names of the functions, and the size of the values that are being
* stored. Rather than having two mostly duplicate definitions of each
* function, we define “template functions” where anything that depends
* on the size of the IP address is defined using the following macros.
*/
/* The name of the cork_ipvX type. */
#define CORK_IP struct cork_ipv6
/* The number of bits in an IPvX address. */
#define IP_BIT_SIZE 128
/* The value of the discriminator variable for an IPvX address. */
#define IP_DISCRIMINATOR_VALUE false
/* Creates a identifier of the form “ipset_ipv6_<basename>”. */
#define IPSET_NAME(basename) ipset_ipv6_##basename
/* Creates a identifier of the form “ipmap_ipv6_<basename>”. */
#define IPMAP_NAME(basename) ipmap_ipv6_##basename
/* Now include all of the templates. */
#include "inspection-template.c.in"
|
281677160/openwrt-package | 2,527 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/cmake/FindCTargets.cmake | # -*- coding: utf-8 -*-
# ----------------------------------------------------------------------
# Copyright © 2015, RedJack, LLC.
# All rights reserved.
#
# Please see the COPYING file in this distribution for license details.
# ----------------------------------------------------------------------
#-----------------------------------------------------------------------
# Library, with options to build both shared and static versions
function(target_add_static_libraries TARGET_NAME LIBRARIES LOCAL_LIBRARIES)
foreach(lib ${LIBRARIES})
string(REPLACE "-" "_" lib ${lib})
string(TOUPPER ${lib} upperlib)
target_link_libraries(
${TARGET_NAME}
${${upperlib}_STATIC_LDFLAGS}
)
endforeach(lib)
foreach(lib ${LOCAL_LIBRARIES})
target_link_libraries(${TARGET_NAME} ${lib})
endforeach(lib)
endfunction(target_add_static_libraries)
set_property(GLOBAL PROPERTY ALL_LOCAL_LIBRARIES "")
function(add_c_library __TARGET_NAME)
set(options)
set(one_args OUTPUT_NAME PKGCONFIG_NAME VERSION)
set(multi_args LIBRARIES LOCAL_LIBRARIES SOURCES)
cmake_parse_arguments(_ "${options}" "${one_args}" "${multi_args}" ${ARGN})
if (__VERSION MATCHES "^([0-9]+)\\.([0-9]+)\\.([0-9]+)(-dev)?$")
set(__VERSION_CURRENT "${CMAKE_MATCH_1}")
set(__VERSION_REVISION "${CMAKE_MATCH_2}")
set(__VERSION_AGE "${CMAKE_MATCH_3}")
else (__VERSION MATCHES "^([0-9]+)\\.([0-9]+)\\.([0-9]+)(-dev)?$")
message(FATAL_ERROR "Invalid library version number: ${__VERSION}")
endif (__VERSION MATCHES "^([0-9]+)\\.([0-9]+)\\.([0-9]+)(-dev)?$")
math(EXPR __SOVERSION "${__VERSION_CURRENT} - ${__VERSION_AGE}")
get_property(ALL_LOCAL_LIBRARIES GLOBAL PROPERTY ALL_LOCAL_LIBRARIES)
list(APPEND ALL_LOCAL_LIBRARIES ${__TARGET_NAME})
set_property(GLOBAL PROPERTY ALL_LOCAL_LIBRARIES "${ALL_LOCAL_LIBRARIES}")
include_directories(
${PROJECT_SOURCE_DIR}/include
${PROJECT_BINARY_DIR}/include
)
add_library(${__TARGET_NAME} STATIC ${__SOURCES})
set_target_properties(
${__TARGET_NAME} PROPERTIES
OUTPUT_NAME ${__OUTPUT_NAME}
CLEAN_DIRECT_OUTPUT 1
)
target_include_directories(
${__TARGET_NAME} PUBLIC
${CMAKE_SOURCE_DIR}/include
${CMAKE_BINARY_DIR}/include
)
target_add_static_libraries(
${__TARGET_NAME}
"${__LIBRARIES}"
"${__LOCAL_LIBRARIES}"
)
endfunction(add_c_library)
|
281677160/openwrt-package | 10,017 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/bdd/read.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2010-2013, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <libcork/core.h>
#include <libcork/ds.h>
#include <libcork/helpers/errors.h>
#include "ipset/bdd/nodes.h"
#include "ipset/errors.h"
#include "ipset/logging.h"
static const char MAGIC_NUMBER[] = "IP set";
static const size_t MAGIC_NUMBER_LENGTH = sizeof(MAGIC_NUMBER) - 1;
/**
* On disk, we use a different node ID scheme than we do in memory.
* Terminal node IDs are non-negative, and are equal to the terminal
* value. Nonterminal node IDs are negative, starting with -1.
* Nonterminal -1 appears first on disk, then nonterminal -2, and so on.
*/
typedef int serialized_id;
/**
* Sets a libcork error based on the contents of errno.
*/
static void
create_errno_error(FILE *stream)
{
if (ferror(stream)) {
cork_error_set(IPSET_ERROR, IPSET_IO_ERROR, "%s", strerror(errno));
} else {
cork_unknown_error();
}
}
/**
* Read in a big-endian uint8 from a stream. If we can't read the
* integer for some reason, return an error.
*/
static int
read_uint8(FILE *stream, uint8_t *dest)
{
size_t num_read = fread(dest, sizeof(uint8_t), 1, stream);
if (num_read != 1) {
create_errno_error(stream);
return -1;
}
/* for a byte, we don't need to endian-swap */
return 0;
}
/**
* Read in a big-endian uint16 from a stream. If we can't read the
* integer for some reason, return an error.
*/
static uint16_t
read_uint16(FILE *stream, uint16_t *dest)
{
size_t num_read = fread(dest, sizeof(uint16_t), 1, stream);
if (num_read != 1) {
create_errno_error(stream);
return -1;
}
CORK_UINT16_BIG_TO_HOST_IN_PLACE(*dest);
return 0;
}
/**
* Read in a big-endian uint32 from a stream. If we can't read the
* integer for some reason, return an error.
*/
static uint32_t
read_uint32(FILE *stream, uint32_t *dest)
{
size_t num_read = fread(dest, sizeof(uint32_t), 1, stream);
if (num_read != 1) {
create_errno_error(stream);
return -1;
}
CORK_UINT32_BIG_TO_HOST_IN_PLACE(*dest);
return 0;
}
/**
* Read in a big-endian uint64 from a stream. If we can't read the
* integer for some reason, return an error.
*/
static uint64_t
read_uint64(FILE *stream, uint64_t *dest)
{
size_t num_read = fread(dest, sizeof(uint64_t), 1, stream);
if (num_read != 1) {
create_errno_error(stream);
return -1;
}
CORK_UINT64_BIG_TO_HOST_IN_PLACE(*dest);
return 0;
}
/**
* A helper function that verifies that we've read exactly as many bytes
* as we should, returning an error otherwise.
*/
static int
verify_cap(size_t bytes_read, size_t cap)
{
if (bytes_read < cap) {
/* There's extra data at the end of the stream. */
cork_error_set
(IPSET_ERROR, IPSET_PARSE_ERROR,
"Malformed set: extra data at end of stream.");
return -1;
} else if (bytes_read > cap) {
/* We read more data than we were supposed to. */
cork_error_set
(IPSET_ERROR, IPSET_PARSE_ERROR,
"Malformed set: read too much data.");
return -1;
}
return 0;
}
/**
* A helper function for reading a version 1 BDD stream.
*/
static ipset_node_id
load_v1(FILE *stream, struct ipset_node_cache *cache)
{
DEBUG("Stream contains v1 IP set");
ipset_node_id result;
struct cork_hash_table *cache_ids = cork_pointer_hash_table_new(0, 0);
/* We've already read in the magic number and version. Next should
* be the length of the encoded set. */
uint64_t length;
DEBUG("Reading encoded length");
ei_check(read_uint64(stream, &length));
/* The length includes the magic number, version number, and the
* length field itself. Remove those to get the cap on the
* remaining stream. */
size_t bytes_read = 0;
size_t cap = length -
MAGIC_NUMBER_LENGTH -
sizeof(uint16_t) -
sizeof(uint64_t);
DEBUG("Length cap is %zu bytes.", cap);
/* Read in the number of nonterminals. */
uint32_t nonterminal_count;
DEBUG("Reading number of nonterminals");
ei_check(read_uint32(stream, &nonterminal_count));
bytes_read += sizeof(uint32_t);
/* If there are no nonterminals, then there's only a single terminal
* left to read. */
if (nonterminal_count == 0) {
uint32_t value;
DEBUG("Reading single terminal value");
ei_check(read_uint32(stream, &value));
bytes_read += sizeof(uint32_t);
/* We should have reached the end of the encoded set. */
ei_check(verify_cap(bytes_read, cap));
/* Create a terminal node for this value and return it. */
cork_hash_table_free(cache_ids);
return ipset_terminal_node_id(value);
}
/* Otherwise, read in each nonterminal. We need to keep track of a
* mapping between each nonterminal's ID in the stream (which are
* number consecutively from -1), and its ID in the node cache
* (which could be anything). */
size_t i;
for (i = 0; i < nonterminal_count; i++) {
serialized_id serialized_id = -(i+1);
/* Each serialized node consists of a variable index, a low
* pointer, and a high pointer. */
uint8_t variable;
ei_check(read_uint8(stream, &variable));
bytes_read += sizeof(uint8_t);
int32_t low;
ei_check(read_uint32(stream, (uint32_t *) &low));
bytes_read += sizeof(int32_t);
int32_t high;
ei_check(read_uint32(stream, (uint32_t *) &high));
bytes_read += sizeof(int32_t);
DEBUG("Read serialized node %d = (x%d? %" PRId32 ": %" PRId32 ")",
serialized_id, variable, high, low);
/* Turn the low pointer into a node ID. If the pointer is >= 0,
* it's a terminal value. Otherwise, its a nonterminal ID,
* indexing into the serialized nonterminal array.*/
ipset_node_id low_id;
if (low >= 0) {
low_id = ipset_terminal_node_id(low);
} else {
/* The file format guarantees that any node reference points
* to a node earlier in the serialized array. That means we
* can assume that cache_ids has already been filled in for
* this node. */
low_id = (ipset_node_id) (uintptr_t)
cork_hash_table_get(cache_ids, (void *) (intptr_t) low);
DEBUG(" Serialized ID %" PRId32 " is internal ID %u",
low, low_id);
}
/* Do the same for the high pointer. */
ipset_node_id high_id;
if (high >= 0) {
high_id = ipset_terminal_node_id(high);
} else {
/* The file format guarantees that any node reference points
* to a node earlier in the serialized array. That means we
* can assume that cache_ids has already been filled in for
* this node. */
high_id = (ipset_node_id) (uintptr_t)
cork_hash_table_get(cache_ids, (void *) (intptr_t) high);
DEBUG(" Serialized ID %" PRId32 " is internal ID %u",
high, high_id);
}
/* Create a nonterminal node in the node cache. */
result = ipset_node_cache_nonterminal
(cache, variable, low_id, high_id);
DEBUG("Internal node %u = nonterminal(x%d? %u: %u)",
result, (int) variable, high_id, low_id);
/* Remember the internal node ID for this new node, in case any
* later serialized nodes point to it. */
cork_hash_table_put
(cache_ids, (void *) (intptr_t) serialized_id,
(void *) (uintptr_t) result, NULL, NULL, NULL);
}
/* We should have reached the end of the encoded set. */
ei_check(verify_cap(bytes_read, cap));
/* The last node is the nonterminal for the entire set. */
cork_hash_table_free(cache_ids);
return result;
error:
/* If there's an error, clean up the objects that we've created
* before returning. */
cork_hash_table_free(cache_ids);
return 0;
}
ipset_node_id
ipset_node_cache_load(FILE *stream, struct ipset_node_cache *cache)
{
size_t bytes_read;
/* First, read in the magic number from the stream to ensure that
* this is an IP set. */
uint8_t magic[MAGIC_NUMBER_LENGTH];
DEBUG("Reading IP set magic number");
bytes_read = fread(magic, 1, MAGIC_NUMBER_LENGTH, stream);
if (ferror(stream)) {
create_errno_error(stream);
return 0;
}
if (bytes_read != MAGIC_NUMBER_LENGTH) {
/* We reached EOF before reading the entire magic number. */
cork_error_set
(IPSET_ERROR, IPSET_PARSE_ERROR,
"Unexpected end of file");
return 0;
}
if (memcmp(magic, MAGIC_NUMBER, MAGIC_NUMBER_LENGTH) != 0) {
/* The magic number doesn't match, so this isn't a BDD. */
cork_error_set
(IPSET_ERROR, IPSET_PARSE_ERROR,
"Magic number doesn't match; this isn't an IP set.");
return 0;
}
/* Read in the version number and dispatch to the right reading
* function. */
uint16_t version;
DEBUG("Reading IP set version");
xi_check(0, read_uint16(stream, &version));
switch (version) {
case 0x0001:
return load_v1(stream, cache);
default:
/* We don't know how to read this version number. */
cork_error_set
(IPSET_ERROR, IPSET_PARSE_ERROR,
"Unknown version number %" PRIu16, version);
return 0;
}
}
|
281677160/openwrt-package | 17,439 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/bdd/basics.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2010-2013, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#include <stdio.h>
#include <string.h>
#include <libcork/core.h>
#include "ipset/bdd/nodes.h"
#include "ipset/bits.h"
#include "ipset/logging.h"
void
ipset_node_fprint(FILE *stream, struct ipset_node *node)
{
fprintf(stream,
"nonterminal(x%u? " IPSET_NODE_ID_FORMAT
": " IPSET_NODE_ID_FORMAT ")",
node->variable,
IPSET_NODE_ID_VALUES(node->high),
IPSET_NODE_ID_VALUES(node->low));
}
static cork_hash
ipset_node_hash(void *user_data, const void *key)
{
const struct ipset_node *node = key;
/* Hash of "ipset_node" */
cork_hash hash = 0xf3b7dc44;
hash = cork_hash_variable(hash, node->variable);
hash = cork_hash_variable(hash, node->low);
hash = cork_hash_variable(hash, node->high);
return hash;
}
static bool
ipset_node_equals(void *user_data, const void *key1, const void *key2)
{
const struct ipset_node *node1 = key1;
const struct ipset_node *node2 = key2;
if (node1 == node2) {
return true;
}
return
(node1->variable == node2->variable) &&
(node1->low == node2->low) &&
(node1->high == node2->high);
}
/* The free list in an ipset_node_cache is represented by a
* singly-linked list of indices into the chunk array. Since the
* ipset_node instance is unused for nodes in the free list, we reuse
* the refcount field to store the "next" index. */
#define IPSET_NULL_INDEX ((ipset_variable) -1)
struct ipset_node_cache *
ipset_node_cache_new()
{
struct ipset_node_cache *cache = cork_new(struct ipset_node_cache);
cork_array_init(&cache->chunks);
cache->largest_index = 0;
cache->free_list = IPSET_NULL_INDEX;
cache->node_cache = cork_hash_table_new(0, 0);
cork_hash_table_set_hash
(cache->node_cache, (cork_hash_f) ipset_node_hash);
cork_hash_table_set_equals
(cache->node_cache, (cork_equals_f) ipset_node_equals);
return cache;
}
void
ipset_node_cache_free(struct ipset_node_cache *cache)
{
size_t i;
for (i = 0; i < cork_array_size(&cache->chunks); i++) {
free(cork_array_at(&cache->chunks, i));
}
cork_array_done(&cache->chunks);
cork_hash_table_free(cache->node_cache);
free(cache);
}
/**
* Returns the index of a new ipset_node instance.
*/
static ipset_value
ipset_node_cache_alloc_node(struct ipset_node_cache *cache)
{
if (cache->free_list == IPSET_NULL_INDEX) {
/* Nothing in the free list; need to allocate a new node. */
ipset_value next_index = cache->largest_index++;
ipset_value chunk_index = next_index >> IPSET_BDD_NODE_CACHE_BIT_SIZE;
if (chunk_index >= cork_array_size(&cache->chunks)) {
/* We've filled up all of the existing chunks, and need to
* create a new one. */
DEBUG(" (allocating chunk %zu)",
cork_array_size(&cache->chunks));
struct ipset_node *new_chunk = cork_calloc
(IPSET_BDD_NODE_CACHE_SIZE, sizeof(struct ipset_node));
cork_array_append(&cache->chunks, new_chunk);
}
return next_index;
} else {
/* Reuse a recently freed node. */
ipset_value next_index = cache->free_list;
struct ipset_node *node =
ipset_node_cache_get_nonterminal_by_index(cache, next_index);
cache->free_list = node->refcount;
return next_index;
}
}
ipset_node_id
ipset_node_incref(struct ipset_node_cache *cache, ipset_node_id node_id)
{
if (ipset_node_get_type(node_id) == IPSET_NONTERMINAL_NODE) {
struct ipset_node *node =
ipset_node_cache_get_nonterminal(cache, node_id);
DEBUG(" [incref " IPSET_NODE_ID_FORMAT "]",
IPSET_NODE_ID_VALUES(node_id));
node->refcount++;
}
return node_id;
}
void
ipset_node_decref(struct ipset_node_cache *cache, ipset_node_id node_id)
{
if (ipset_node_get_type(node_id) == IPSET_NONTERMINAL_NODE) {
struct ipset_node *node =
ipset_node_cache_get_nonterminal(cache, node_id);
DEBUG(" [decref " IPSET_NODE_ID_FORMAT "]",
IPSET_NODE_ID_VALUES(node_id));
if (--node->refcount == 0) {
DEBUG(" [free " IPSET_NODE_ID_FORMAT "]",
IPSET_NODE_ID_VALUES(node_id));
ipset_node_decref(cache, node->low);
ipset_node_decref(cache, node->high);
cork_hash_table_delete(cache->node_cache, node, NULL, NULL);
/* Add the node to the free list */
node->refcount = cache->free_list;
cache->free_list = ipset_nonterminal_value(node_id);
}
}
}
bool
ipset_node_cache_nodes_equal(const struct ipset_node_cache *cache1,
ipset_node_id node_id1,
const struct ipset_node_cache *cache2,
ipset_node_id node_id2)
{
struct ipset_node *node1;
struct ipset_node *node2;
if (ipset_node_get_type(node_id1) != ipset_node_get_type(node_id2)) {
return false;
}
if (ipset_node_get_type(node_id1) == IPSET_TERMINAL_NODE) {
return node_id1 == node_id2;
}
node1 = ipset_node_cache_get_nonterminal(cache1, node_id1);
node2 = ipset_node_cache_get_nonterminal(cache2, node_id2);
return
(node1->variable == node2->variable) &&
ipset_node_cache_nodes_equal(cache1, node1->low, cache2, node2->low) &&
ipset_node_cache_nodes_equal(cache1, node1->high, cache2, node2->high);
}
ipset_node_id
ipset_node_cache_nonterminal(struct ipset_node_cache *cache,
ipset_variable variable,
ipset_node_id low, ipset_node_id high)
{
/* Don't allow any nonterminals whose low and high subtrees are the
* same, since the nonterminal would be redundant. */
if (CORK_UNLIKELY(low == high)) {
DEBUG(" [ SKIP nonterminal(x%u? "
IPSET_NODE_ID_FORMAT ": " IPSET_NODE_ID_FORMAT ")]",
variable, IPSET_NODE_ID_VALUES(high), IPSET_NODE_ID_VALUES(low));
ipset_node_decref(cache, high);
return low;
}
/* Check to see if there's already a nonterminal with these contents
* in the cache. */
DEBUG(" [search nonterminal(x%u? "
IPSET_NODE_ID_FORMAT ": " IPSET_NODE_ID_FORMAT ")]",
variable, IPSET_NODE_ID_VALUES(high), IPSET_NODE_ID_VALUES(low));
struct ipset_node search_node;
search_node.variable = variable;
search_node.low = low;
search_node.high = high;
bool is_new;
struct cork_hash_table_entry *entry =
cork_hash_table_get_or_create
(cache->node_cache, &search_node, &is_new);
if (!is_new) {
/* There's already a node with these contents, so return its ID. */
ipset_node_id node_id = (uintptr_t) entry->value;
DEBUG(" [reuse " IPSET_NODE_ID_FORMAT "]",
IPSET_NODE_ID_VALUES(node_id));
ipset_node_incref(cache, node_id);
ipset_node_decref(cache, low);
ipset_node_decref(cache, high);
return node_id;
} else {
/* This node doesn't exist yet. Allocate a permanent copy of
* the node, add it to the cache, and then return its ID. */
ipset_value new_index = ipset_node_cache_alloc_node(cache);
ipset_node_id new_node_id = ipset_nonterminal_node_id(new_index);
struct ipset_node *real_node =
ipset_node_cache_get_nonterminal_by_index(cache, new_index);
real_node->refcount = 1;
real_node->variable = variable;
real_node->low = low;
real_node->high = high;
entry->key = real_node;
entry->value = (void *) (uintptr_t) new_node_id;
DEBUG(" [new " IPSET_NODE_ID_FORMAT "]",
IPSET_NODE_ID_VALUES(new_node_id));
return new_node_id;
}
}
bool
ipset_bool_array_assignment(const void *user_data, ipset_variable variable)
{
const bool *bool_array = (const bool *) user_data;
return bool_array[variable];
}
bool
ipset_bit_array_assignment(const void *user_data, ipset_variable variable)
{
return IPSET_BIT_GET(user_data, variable);
}
ipset_value
ipset_node_evaluate(const struct ipset_node_cache *cache, ipset_node_id node_id,
ipset_assignment_func assignment, const void *user_data)
{
ipset_node_id curr_node_id = node_id;
DEBUG("Evaluating BDD node " IPSET_NODE_ID_FORMAT,
IPSET_NODE_ID_VALUES(node_id));
/* As long as the current node is a nonterminal, we have to check
* the value of the current variable. */
while (ipset_node_get_type(curr_node_id) == IPSET_NONTERMINAL_NODE) {
/* We have to look up this variable in the assignment. */
struct ipset_node *node =
ipset_node_cache_get_nonterminal(cache, curr_node_id);
bool this_value = assignment(user_data, node->variable);
DEBUG("[%3u] Nonterminal " IPSET_NODE_ID_FORMAT,
node->variable, IPSET_NODE_ID_VALUES(curr_node_id));
DEBUG("[%3u] x%u = %s",
node->variable, node->variable, this_value? "TRUE": "FALSE");
if (this_value) {
/* This node's variable is true in the assignment vector, so
* trace down the high subtree. */
curr_node_id = node->high;
} else {
/* This node's variable is false in the assignment vector,
* so trace down the low subtree. */
curr_node_id = node->low;
}
}
/* Once we find a terminal node, we've got the final result. */
DEBUG("Evaluated result is %u", ipset_terminal_value(curr_node_id));
return ipset_terminal_value(curr_node_id);
}
/* A “fake” BDD node given by an assignment. */
struct ipset_fake_node {
ipset_variable current_var;
ipset_variable var_count;
ipset_assignment_func assignment;
const void *user_data;
ipset_value value;
};
/* A fake BDD node representing the terminal 0 value. */
static struct ipset_fake_node fake_terminal_0 = { 0, 0, NULL, 0, 0 };
/* We set elements in a map using the if-then-else (ITE) operator:
*
* new_set = new_element? new_value: old_set
*
* The below is a straight copy of the standard trinary APPLY from the BDD
* literature, but without the caching of the results. And also with the
* wrinkle that the F argument to ITE (i.e., new_element) is given by an
* assignment, and not by a BDD node. (This lets us skip constructing the BDD
* for the assignment, saving us a few cycles.)
*/
static ipset_node_id
ipset_apply_ite(struct ipset_node_cache *cache, struct ipset_fake_node *f,
ipset_value g, ipset_node_id h)
{
ipset_node_id h_low;
ipset_node_id h_high;
ipset_node_id result_low;
ipset_node_id result_high;
/* If F is a terminal, then we're in one of the following two
* cases:
*
* 1? G: H == G
* 0? G: H == H
*/
if (f->current_var == f->var_count) {
ipset_node_id result;
DEBUG("[%3u] F is terminal (value %u)", f->current_var, f->value);
if (f->value == 0) {
DEBUG("[%3u] 0? " IPSET_NODE_ID_FORMAT ": " IPSET_NODE_ID_FORMAT
" = " IPSET_NODE_ID_FORMAT,
f->current_var,
IPSET_NODE_ID_VALUES(ipset_terminal_node_id(g)),
IPSET_NODE_ID_VALUES(h), IPSET_NODE_ID_VALUES(h));
result = ipset_node_incref(cache, h);
} else {
result = ipset_terminal_node_id(g);
DEBUG("[%3u] 1? " IPSET_NODE_ID_FORMAT ": " IPSET_NODE_ID_FORMAT
" = " IPSET_NODE_ID_FORMAT,
f->current_var, IPSET_NODE_ID_VALUES(result),
IPSET_NODE_ID_VALUES(h), IPSET_NODE_ID_VALUES(result));
}
return result;
}
/* F? G: G == G */
if (h == ipset_terminal_node_id(g)) {
DEBUG("[%3u] F? " IPSET_NODE_ID_FORMAT ": " IPSET_NODE_ID_FORMAT
" = " IPSET_NODE_ID_FORMAT,
f->current_var, IPSET_NODE_ID_VALUES(h),
IPSET_NODE_ID_VALUES(h), IPSET_NODE_ID_VALUES(h));
return h;
}
/* From here to the end of the function, we know that F is a
* nonterminal. */
DEBUG("[%3u] F is nonterminal", f->current_var);
/* We're going to do two recursive calls, a “low” one and a “high” one. For
* each nonterminal that has the minimum variable number, we use its low and
* high pointers in the respective recursive call. For all other
* nonterminals, and for all terminals, we use the operand itself. */
if (ipset_node_get_type(h) == IPSET_NONTERMINAL_NODE) {
struct ipset_node *h_node =
ipset_node_cache_get_nonterminal(cache, h);
DEBUG("[%3u] H is nonterminal (variable %u)",
f->current_var, h_node->variable);
if (h_node->variable < f->current_var) {
/* var(F) > var(H), so we only recurse down the H branches. */
DEBUG("[%3u] Recursing only down H", f->current_var);
DEBUG("[%3u] Recursing high", f->current_var);
result_high = ipset_apply_ite(cache, f, g, h_node->high);
DEBUG("[%3u] Back from high recursion", f->current_var);
DEBUG("[%3u] Recursing low", f->current_var);
result_low = ipset_apply_ite(cache, f, g, h_node->low);
DEBUG("[%3u] Back from low recursion", f->current_var);
return ipset_node_cache_nonterminal
(cache, h_node->variable, result_low, result_high);
} else if (h_node->variable == f->current_var) {
/* var(F) == var(H), so we recurse down both branches. */
DEBUG("[%3u] Recursing down both F and H", f->current_var);
h_low = h_node->low;
h_high = h_node->high;
} else {
/* var(F) < var(H), so we only recurse down the F branches. */
DEBUG("[%3u] Recursing only down F", f->current_var);
h_low = h;
h_high = h;
}
} else {
/* H in nonterminal, so we only recurse down the F branches. */
DEBUG("[%3u] H is terminal (value %u)",
f->current_var, ipset_terminal_value(h));
DEBUG("[%3u] Recursing only down F", f->current_var);
h_low = h;
h_high = h;
}
/* F is a “fake” nonterminal node, since it comes from our assignment. One
* of its branches will be the 0 terminal, and the other will be the fake
* nonterminal for the next variable in the assignment. (Which one is low
* and which one is high depends on the value of the current variable in the
* assignment.) */
if (f->assignment(f->user_data, f->current_var)) {
/* The current variable is set in F. The low branch is terminal 0; the
* high branch is the next variable in F. */
DEBUG("[%3u] x[%u] is set", f->current_var, f->current_var);
DEBUG("[%3u] Recursing high", f->current_var);
f->current_var++;
result_high = ipset_apply_ite(cache, f, g, h_high);
f->current_var--;
DEBUG("[%3u] Back from high recursion: " IPSET_NODE_ID_FORMAT,
f->current_var, IPSET_NODE_ID_VALUES(result_high));
DEBUG("[%3u] Recursing low", f->current_var);
fake_terminal_0.current_var = f->var_count;
fake_terminal_0.var_count = f->var_count;
result_low = ipset_apply_ite(cache, &fake_terminal_0, g, h_low);
DEBUG("[%3u] Back from low recursion: " IPSET_NODE_ID_FORMAT,
f->current_var, IPSET_NODE_ID_VALUES(result_low));
} else {
/* The current variable is NOT set in F. The high branch is terminal 0;
* the low branch is the next variable in F. */
DEBUG("[%3u] x[%u] is NOT set", f->current_var, f->current_var);
DEBUG("[%3u] Recursing high", f->current_var);
fake_terminal_0.current_var = f->var_count;
fake_terminal_0.var_count = f->var_count;
result_high = ipset_apply_ite(cache, &fake_terminal_0, g, h_high);
DEBUG("[%3u] Back from high recursion: " IPSET_NODE_ID_FORMAT,
f->current_var, IPSET_NODE_ID_VALUES(result_high));
DEBUG("[%3u] Recursing low", f->current_var);
f->current_var++;
result_low = ipset_apply_ite(cache, f, g, h_low);
f->current_var--;
DEBUG("[%3u] Back from low recursion: " IPSET_NODE_ID_FORMAT,
f->current_var, IPSET_NODE_ID_VALUES(result_low));
}
return ipset_node_cache_nonterminal
(cache, f->current_var, result_low, result_high);
}
ipset_node_id
ipset_node_insert(struct ipset_node_cache *cache, ipset_node_id node,
ipset_assignment_func assignment, const void *user_data,
ipset_variable var_count, ipset_value value)
{
struct ipset_fake_node f = { 0, var_count, assignment, user_data, 1 };
DEBUG("Inserting new element");
return ipset_apply_ite(cache, &f, value, node);
}
|
281677160/openwrt-package | 3,773 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/bdd/assignments.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2010-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#include <libcork/core.h>
#include "ipset/bdd/nodes.h"
struct ipset_assignment *
ipset_assignment_new()
{
struct ipset_assignment *assignment = cork_new(struct ipset_assignment);
cork_array_init(&assignment->values);
return assignment;
}
void
ipset_assignment_free(struct ipset_assignment *assignment)
{
cork_array_done(&assignment->values);
free(assignment);
}
bool
ipset_assignment_equal(const struct ipset_assignment *assignment1,
const struct ipset_assignment *assignment2)
{
/* Identical pointers are trivially equal. */
if (assignment1 == assignment2) {
return true;
}
/* Otherwise we compare the assignments piecewise up through the end
* of the smaller vector. */
unsigned int size1 = cork_array_size(&assignment1->values);
unsigned int size2 = cork_array_size(&assignment2->values);
unsigned int smaller_size = (size1 < size2)? size1: size2;
unsigned int i;
for (i = 0; i < smaller_size; i++) {
if (cork_array_at(&assignment1->values, i) !=
cork_array_at(&assignment2->values, i)) {
return false;
}
}
/* If one of the assignment vectors is longer, any remaining
* elements must be indeterminate. */
if (size1 > smaller_size) {
for (i = smaller_size; i < size1; i++) {
if (cork_array_at(&assignment1->values, i) != IPSET_EITHER) {
return false;
}
}
}
if (size2 > smaller_size) {
for (i = smaller_size; i < size2; i++) {
if (cork_array_at(&assignment2->values, i) != IPSET_EITHER) {
return false;
}
}
}
/* If we make it through all of that, the two assignments are equal. */
return true;
}
void
ipset_assignment_cut(struct ipset_assignment *assignment,
ipset_variable var)
{
if (var < cork_array_size(&assignment->values)) {
assignment->values.size = var;
}
}
void
ipset_assignment_clear(struct ipset_assignment *assignment)
{
ipset_assignment_cut(assignment, 0);
}
enum ipset_tribool
ipset_assignment_get(struct ipset_assignment *assignment, ipset_variable var)
{
if (var < cork_array_size(&assignment->values)) {
/* If the requested variable is in the range of the values
* array, return whatever is stored there. */
return cork_array_at(&assignment->values, var);
} else {
/* Variables htat aren't in the values array are always EITHER. */
return IPSET_EITHER;
}
}
void
ipset_assignment_set(struct ipset_assignment *assignment,
ipset_variable var, enum ipset_tribool value)
{
/* Ensure that the vector is big enough to hold this variable
* assignment, inserting new EITHERs if needed. */
if (var >= cork_array_size(&assignment->values)) {
unsigned int old_len = cork_array_size(&assignment->values);
/* Expand the array. */
cork_array_ensure_size(&assignment->values, var+1);
assignment->values.size = var+1;
/* Fill in EITHERs in the newly allocated elements. */
if (var != old_len) {
unsigned int i;
for (i = old_len; i < var; i++) {
cork_array_at(&assignment->values, i) = IPSET_EITHER;
}
}
}
/* Assign the desired value. */
cork_array_at(&assignment->values, var) = value;
}
|
281677160/openwrt-package | 4,382 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/bdd/expanded.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2010-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#include <string.h>
#include <libcork/core.h>
#include "ipset/bdd/nodes.h"
#include "ipset/bits.h"
#include "ipset/logging.h"
static void
initialize(struct ipset_expanded_assignment *exp,
const struct ipset_assignment *assignment,
ipset_variable var_count)
{
/* First loop through all of the variables in the assignment vector,
* making sure not to go further than the caller requested. */
ipset_variable last_assignment = cork_array_size(&assignment->values);
if (var_count < last_assignment) {
last_assignment = var_count;
}
ipset_variable var;
for (var = 0; var < last_assignment; var++) {
enum ipset_tribool curr_value =
cork_array_at(&assignment->values, var);
if (curr_value == IPSET_EITHER) {
/* If this variable is EITHER, start it off as FALSE, and
* add it to the eithers list. */
DEBUG("Variable %u is EITHER", var);
IPSET_BIT_SET(exp->values.buf, var, false);
cork_array_append(&exp->eithers, var);
} else {
/* Otherwise set the variable to the same value in the
* expanded assignment as it is in the non-expanded one. */
DEBUG("Variable %u is %s", var, curr_value? "true": "false");
IPSET_BIT_SET(exp->values.buf, var, curr_value);
}
}
/* If the caller requested more variables than there are in the
* assignment vector, add them to the eithers list. */
for (var = last_assignment; var < var_count; var++) {
DEBUG("Variable %u is implicitly EITHER", var);
cork_array_append(&exp->eithers, var);
}
}
struct ipset_expanded_assignment *
ipset_assignment_expand(const struct ipset_assignment *assignment,
ipset_variable var_count)
{
/* First allocate the iterator itself, and all of its contained
* fields. */
struct ipset_expanded_assignment *exp;
unsigned int values_size = (var_count / 8) + ((var_count % 8) != 0);
exp = cork_new(struct ipset_expanded_assignment);
exp->finished = false;
cork_buffer_init(&exp->values);
cork_buffer_ensure_size(&exp->values, values_size);
memset(exp->values.buf, 0, values_size);
cork_array_init(&exp->eithers);
/* Then initialize the values and eithers fields. */
initialize(exp, assignment, var_count);
return exp;
}
void
ipset_expanded_assignment_free(struct ipset_expanded_assignment *exp)
{
if (exp == NULL) {
return;
}
cork_buffer_done(&exp->values);
cork_array_done(&exp->eithers);
free(exp);
}
void
ipset_expanded_assignment_advance(struct ipset_expanded_assignment *exp)
{
/* If we're already at the end of the iterator, don't do anything. */
if (CORK_UNLIKELY(exp->finished)) {
return;
}
DEBUG("Advancing iterator");
/* Look at the last EITHER bit in the assignment. If it's 0, then
* set it to 1 and return. Otherwise we set it to 0 and carry up to
* the previous indeterminate bit. */
size_t i;
for (i = cork_array_size(&exp->eithers); i > 0; i--) {
size_t idx = i - 1;
ipset_variable either_var = cork_array_at(&exp->eithers, idx);
DEBUG("Checking EITHER variable %u", either_var);
if (IPSET_BIT_GET(exp->values.buf, either_var)) {
/* This variable is currently true, so set it back to false
* and carry. */
DEBUG(" Variable %u is true, changing to false and carrying",
either_var);
IPSET_BIT_SET(exp->values.buf, either_var, false);
} else {
/* This variable is currently false, so set it to true and
* return. */
DEBUG(" Variable %u is false, changing to true",
either_var);
IPSET_BIT_SET(exp->values.buf, either_var, true);
return;
}
}
/* If we fall through then we've made it through all of the expanded
* assignments. */
exp->finished = true;
}
|
281677160/openwrt-package | 2,670 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/bdd/reachable.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2010-2013, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#include <libcork/core.h>
#include <libcork/ds.h>
#include "ipset/bdd/nodes.h"
#include "ipset/logging.h"
size_t
ipset_node_reachable_count(const struct ipset_node_cache *cache,
ipset_node_id node)
{
/* Create a set to track when we've visited a given node. */
struct cork_hash_table *visited = cork_pointer_hash_table_new(0, 0);
/* And a queue of nodes to check. */
cork_array(ipset_node_id) queue;
cork_array_init(&queue);
if (ipset_node_get_type(node) == IPSET_NONTERMINAL_NODE) {
DEBUG("Adding node %u to queue", node);
cork_array_append(&queue, node);
}
/* And somewhere to store the result. */
size_t node_count = 0;
/* Check each node in turn. */
while (!cork_array_is_empty(&queue)) {
ipset_node_id curr = cork_array_at(&queue, --queue.size);
/* We don't have to do anything if this node is already in the
* visited set. */
if (cork_hash_table_get(visited, (void *) (uintptr_t) curr) == NULL) {
DEBUG("Visiting node %u for the first time", curr);
/* Add the node to the visited set. */
cork_hash_table_put
(visited, (void *) (uintptr_t) curr,
(void *) (uintptr_t) true, NULL, NULL, NULL);
/* Increase the node count. */
node_count++;
/* And add the node's nonterminal children to the visit
* queue. */
struct ipset_node *node =
ipset_node_cache_get_nonterminal(cache, curr);
if (ipset_node_get_type(node->low) == IPSET_NONTERMINAL_NODE) {
DEBUG("Adding node %u to queue", node->low);
cork_array_append(&queue, node->low);
}
if (ipset_node_get_type(node->high) == IPSET_NONTERMINAL_NODE) {
DEBUG("Adding node %u to queue", node->high);
cork_array_append(&queue, node->high);
}
}
}
/* Return the result, freeing everything before we go. */
cork_hash_table_free(visited);
cork_array_done(&queue);
return node_count;
}
size_t
ipset_node_memory_size(const struct ipset_node_cache *cache,
ipset_node_id node)
{
return ipset_node_reachable_count(cache, node) * sizeof(struct ipset_node);
}
|
281677160/openwrt-package | 17,603 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/bdd/write.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2010-2013, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#include <libcork/core.h>
#include <libcork/helpers/errors.h>
#include "ipset/bdd/nodes.h"
#include "ipset/logging.h"
/*-----------------------------------------------------------------------
* Generic saving logic
*/
/**
* On disk, we use a different node ID scheme than we do in memory.
* Terminal node IDs are non-negative, and are equal to the terminal
* value. Nonterminal node IDs are negative, starting with -1.
* Nonterminal -1 appears first on disk, then nonterminal -2, and so
* on.
*/
typedef int serialized_id;
/* forward declaration */
struct save_data;
/**
* A callback that outputs any necessary header. Should return an int
* status code indicating whether the write was successful.
*/
typedef int
(*write_header_func)(struct save_data *save_data,
struct ipset_node_cache *cache,
ipset_node_id root);
/**
* A callback that outputs any necessary footer. Should return an int
* status code indicating whether the write was successful.
*/
typedef int
(*write_footer_func)(struct save_data *save_data,
struct ipset_node_cache *cache,
ipset_node_id root);
/**
* A callback that actually outputs a terminal node to disk. Should
* return an int status code indicating whether the write was successful.
*/
typedef int
(*write_terminal_func)(struct save_data *save_data,
ipset_value terminal_value);
/**
* A callback that actually outputs a nonterminal node to disk.
* Should return an int status code indicating whether the write was
* successful.
*/
typedef int
(*write_nonterminal_func)(struct save_data *save_data,
serialized_id serialized_node,
ipset_variable variable,
serialized_id serialized_low,
serialized_id serialized_high);
/**
* A helper struct containing all of the persistent data items needed
* during the execution of a save.
*/
struct save_data {
/* The node cache that we're saving nodes from. */
struct ipset_node_cache *cache;
/* The output stream to save the data to. */
struct cork_stream_consumer *stream;
/* The cache of serialized IDs for any nonterminals that we've
* encountered so far. */
struct cork_hash_table *serialized_ids;
/* The serialized ID to use for the next nonterminal that we
* encounter. */
serialized_id next_serialized_id;
/* The callback used to write the file header to the stream. */
write_header_func write_header;
/* The callback used to write the file footer to the stream. */
write_footer_func write_footer;
/* The callback used to write terminals to the stream. */
write_terminal_func write_terminal;
/* The callback used to write nonterminals to the stream. */
write_nonterminal_func write_nonterminal;
/* A pointer to any additional data needed by the callbacks. */
void *user_data;
};
/**
* A helper function for ipset_node_save(). Outputs a nonterminal
* node in a BDD tree, if we haven't done so already. Ensures that
* the children of the nonterminal are output before the nonterminal
* is. Returns the serialized ID of this node.
*/
static int
save_visit_node(struct save_data *save_data,
ipset_node_id node_id, serialized_id *dest)
{
/* Check whether we've already serialized this node. */
struct cork_hash_table_entry *entry;
bool is_new;
entry = cork_hash_table_get_or_create
(save_data->serialized_ids, (void *) (uintptr_t) node_id, &is_new);
if (!is_new) {
*dest = (intptr_t) entry->value;
return 0;
} else {
if (ipset_node_get_type(node_id) == IPSET_TERMINAL_NODE) {
/* For terminals, there isn't really anything to do — we
* just output the terminal node and use its value as the
* serialized ID. */
ipset_value value = ipset_terminal_value(node_id);
DEBUG("Writing terminal(%d)", value);
rii_check(save_data->write_terminal(save_data, value));
entry->value = (void *) (intptr_t) value;
*dest = value;
return 0;
} else {
/* For nonterminals, we drill down into the node's children
* first, then output the nonterminal node. */
struct ipset_node *node =
ipset_node_cache_get_nonterminal(save_data->cache, node_id);
DEBUG("Visiting node %u nonterminal(x%u? %u: %u)",
node_id, node->variable, node->high, node->low);
/* Output the node's nonterminal children before we output
* the node itself. */
serialized_id serialized_low;
serialized_id serialized_high;
rii_check(save_visit_node(save_data, node->low, &serialized_low));
rii_check(save_visit_node(save_data, node->high, &serialized_high));
/* Output the nonterminal */
serialized_id result = save_data->next_serialized_id--;
DEBUG("Writing node %u as serialized node %d = (x%u? %d: %d)",
node_id, result,
node->variable, serialized_low, serialized_high);
entry->value = (void *) (intptr_t) result;
*dest = result;
return save_data->write_nonterminal
(save_data, result, node->variable,
serialized_low, serialized_high);
}
}
}
static int
save_bdd(struct save_data *save_data,
struct ipset_node_cache *cache, ipset_node_id root)
{
/* First, output the file header. */
DEBUG("Writing file header");
rii_check(save_data->write_header(save_data, cache, root));
/* The serialized node IDs are different than the in-memory node
* IDs. This means that, for our nonterminal nodes, we need a
* mapping from internal node ID to serialized node ID. */
DEBUG("Creating file caches");
save_data->serialized_ids = cork_pointer_hash_table_new(0, 0);
save_data->next_serialized_id = -1;
/* Trace down through the BDD tree, outputting each terminal and
* nonterminal node as they're encountered. */
DEBUG("Writing nodes");
serialized_id last_serialized_id;
ei_check(save_visit_node(save_data, root, &last_serialized_id));
/* Finally, output the file footer and cleanup. */
DEBUG("Writing file footer");
ei_check(save_data->write_footer(save_data, cache, root));
DEBUG("Freeing file caches");
cork_hash_table_free(save_data->serialized_ids);
return 0;
error:
/* If there's an error, clean up the objects that we've created
* before returning. */
cork_hash_table_free(save_data->serialized_ids);
return -1;
}
/*-----------------------------------------------------------------------
* Helper functions
*/
/**
* Write a NUL-terminated string to a stream. If we can't write the
* string for some reason, return an error.
*/
static int
write_string(struct cork_stream_consumer *stream, const char *str)
{
size_t len = strlen(str);
return cork_stream_consumer_data(stream, str, len, false);
}
/**
* Write a big-endian uint8 to a stream. If we can't write the
* integer for some reason, return an error.
*/
static int
write_uint8(struct cork_stream_consumer *stream, uint8_t val)
{
/* for a byte, we don't need to endian-swap */
return cork_stream_consumer_data(stream, &val, sizeof(uint8_t), false);
}
/**
* Write a big-endian uint16 to a stream. If we can't write the
* integer for some reason, return an error.
*/
static int
write_uint16(struct cork_stream_consumer *stream, uint16_t val)
{
CORK_UINT16_HOST_TO_BIG_IN_PLACE(val);
return cork_stream_consumer_data(stream, &val, sizeof(uint16_t), false);
}
/**
* Write a big-endian uint32 to a stream. If we can't write the
* integer for some reason, return an error.
*/
static int
write_uint32(struct cork_stream_consumer *stream, uint32_t val)
{
CORK_UINT32_HOST_TO_BIG_IN_PLACE(val);
return cork_stream_consumer_data(stream, &val, sizeof(uint32_t), false);
}
/**
* Write a big-endian uint64 to a stream. If we can't write the
* integer for some reason, return an error.
*/
static int
write_uint64(struct cork_stream_consumer *stream, uint64_t val)
{
CORK_UINT64_HOST_TO_BIG_IN_PLACE(val);
return cork_stream_consumer_data(stream, &val, sizeof(uint64_t), false);
}
/*-----------------------------------------------------------------------
* V1 BDD file
*/
static const char MAGIC_NUMBER[] = "IP set";
static const size_t MAGIC_NUMBER_LENGTH = sizeof(MAGIC_NUMBER) - 1;
static int
write_header_v1(struct save_data *save_data,
struct ipset_node_cache *cache, ipset_node_id root)
{
/* Output the magic number for an IP set, and the file format
* version that we're going to write. */
rii_check(cork_stream_consumer_data(save_data->stream, NULL, 0, true));
rii_check(write_string(save_data->stream, MAGIC_NUMBER));
rii_check(write_uint16(save_data->stream, 0x0001));
/* Determine how many reachable nodes there are, to calculate the
* size of the set. */
size_t nonterminal_count = ipset_node_reachable_count(cache, root);
size_t set_size =
MAGIC_NUMBER_LENGTH + /* magic number */
sizeof(uint16_t) + /* version number */
sizeof(uint64_t) + /* length of set */
sizeof(uint32_t) + /* number of nonterminals */
(nonterminal_count * /* for each nonterminal: */
(sizeof(uint8_t) + /* variable number */
sizeof(uint32_t) + /* low pointer */
sizeof(uint32_t) /* high pointer */
));
/* If the root is a terminal, we need to add 4 bytes to the set
* size, for storing the terminal value. */
if (ipset_node_get_type(root) == IPSET_TERMINAL_NODE) {
set_size += sizeof(uint32_t);
}
rii_check(write_uint64(save_data->stream, set_size));
rii_check(write_uint32(save_data->stream, nonterminal_count));
return 0;
}
static int
write_footer_v1(struct save_data *save_data,
struct ipset_node_cache *cache, ipset_node_id root)
{
/* If the root is a terminal node, then we output the terminal value
* in place of the (nonexistent) list of nonterminal nodes. */
if (ipset_node_get_type(root) == IPSET_TERMINAL_NODE) {
ipset_value value = ipset_terminal_value(root);
return write_uint32(save_data->stream, value);
}
return 0;
}
static int
write_terminal_v1(struct save_data *save_data, ipset_value terminal_value)
{
/* We don't have to write anything out for a terminal in a V1 file,
* since the terminal's value will be encoded into the node ID
* wherever it's used. */
return 0;
}
static int
write_nonterminal_v1(struct save_data *save_data,
serialized_id serialized_node,
ipset_variable variable,
serialized_id serialized_low,
serialized_id serialized_high)
{
rii_check(write_uint8(save_data->stream, variable));
rii_check(write_uint32(save_data->stream, serialized_low));
rii_check(write_uint32(save_data->stream, serialized_high));
return 0;
}
int
ipset_node_cache_save(struct cork_stream_consumer *stream, struct ipset_node_cache *cache,
ipset_node_id node)
{
struct save_data save_data;
save_data.cache = cache;
save_data.stream = stream;
save_data.write_header = write_header_v1;
save_data.write_footer = write_footer_v1;
save_data.write_terminal = write_terminal_v1;
save_data.write_nonterminal = write_nonterminal_v1;
return save_bdd(&save_data, cache, node);
}
/*-----------------------------------------------------------------------
* GraphViz dot file
*/
static const char *GRAPHVIZ_HEADER =
"strict digraph bdd {\n";
static const char *GRAPHVIZ_FOOTER =
"}\n";
struct dot_data {
/* The terminal value to leave out of the dot file. This should be
* the default value of the set or map. */
ipset_value default_value;
/* A scratch buffer */
struct cork_buffer scratch;
};
static int
write_header_dot(struct save_data *save_data,
struct ipset_node_cache *cache, ipset_node_id root)
{
/* Output the opening clause of the GraphViz script. */
rii_check(cork_stream_consumer_data(save_data->stream, NULL, 0, true));
return write_string(save_data->stream, GRAPHVIZ_HEADER);
}
static int
write_footer_dot(struct save_data *save_data,
struct ipset_node_cache *cache, ipset_node_id root)
{
/* Output the closing clause of the GraphViz script. */
return write_string(save_data->stream, GRAPHVIZ_FOOTER);
}
static int
write_terminal_dot(struct save_data *save_data, ipset_value terminal_value)
{
struct dot_data *dot_data = save_data->user_data;
/* If this terminal has the default value, skip it. */
if (terminal_value == dot_data->default_value) {
return 0;
}
/* Output a node for the terminal value. */
cork_buffer_printf
(&dot_data->scratch,
" t%d [shape=box, label=%d];\n",
terminal_value, terminal_value);
return write_string(save_data->stream, dot_data->scratch.buf);
}
static int
write_nonterminal_dot(struct save_data *save_data,
serialized_id serialized_node,
ipset_variable variable,
serialized_id serialized_low,
serialized_id serialized_high)
{
struct dot_data *dot_data = save_data->user_data;
/* Include a node for the nonterminal value. */
cork_buffer_printf
(&dot_data->scratch,
" n%d [shape=circle,label=%u];\n",
(-serialized_node), variable);
/* Include an edge for the low pointer. */
if (serialized_low < 0) {
/* The low pointer is a nonterminal. */
cork_buffer_append_printf
(&dot_data->scratch,
" n%d -> n%d",
(-serialized_node), (-serialized_low));
} else {
/* The low pointer is a terminal. */
ipset_value low_value = (ipset_value) serialized_low;
if (low_value == dot_data->default_value) {
/* The terminal is the default value, so instead of a real
* terminal, connect this pointer to a dummy circle node. */
cork_buffer_append_printf
(&dot_data->scratch,
" low%d [shape=circle,label=\"\"]\n"
" n%d -> low%d",
(-serialized_node), (-serialized_node), (-serialized_node));
} else {
/* The terminal isn't a default, so go ahead and output it. */
cork_buffer_append_printf
(&dot_data->scratch,
" n%d -> t%d",
(-serialized_node), serialized_low);
}
}
cork_buffer_append_printf
(&dot_data->scratch, " [style=dashed,color=red]\n");
/* Include an edge for the high pointer. */
if (serialized_high < 0) {
/* The high pointer is a nonterminal. */
cork_buffer_append_printf
(&dot_data->scratch,
" n%d -> n%d",
(-serialized_node), (-serialized_high));
} else {
/* The high pointer is a terminal. */
ipset_value high_value = (ipset_value) serialized_high;
if (high_value == dot_data->default_value) {
/* The terminal is the default value, so instead of a real
* terminal, connect this pointer to a dummy circle node. */
cork_buffer_append_printf
(&dot_data->scratch,
" high%d "
"[shape=circle,"
"fixedsize=true,"
"height=0.25,"
"width=0.25,"
"label=\"\"]\n"
" n%d -> high%d",
(-serialized_node), (-serialized_node), (-serialized_node));
} else {
/* The terminal isn't a default, so go ahead and output it. */
cork_buffer_append_printf
(&dot_data->scratch,
" n%d -> t%d",
(-serialized_node), serialized_high);
}
}
cork_buffer_append_printf
(&dot_data->scratch, " [style=solid,color=black]\n");
/* Output the clauses to the stream. */
return write_string(save_data->stream, dot_data->scratch.buf);
}
int
ipset_node_cache_save_dot(struct cork_stream_consumer *stream,
struct ipset_node_cache *cache, ipset_node_id node)
{
struct dot_data dot_data = {
0, /* default value */
{NULL, 0, 0}
};
struct save_data save_data;
save_data.cache = cache;
save_data.stream = stream;
save_data.write_header = write_header_dot;
save_data.write_footer = write_footer_dot;
save_data.write_terminal = write_terminal_dot;
save_data.write_nonterminal = write_nonterminal_dot;
save_data.user_data = &dot_data;
return save_bdd(&save_data, cache, node);
}
|
281677160/openwrt-package | 4,454 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/bdd/bdd-iterator.c | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2010-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#include <libcork/core.h>
#include "ipset/bdd/nodes.h"
#include "ipset/logging.h"
/**
* Add the given node ID to the node stack, and trace down from it
* until we find a terminal node. Assign values to the variables for
* each nonterminal that encounter along the way. We check low edges
* first, so each new variable we encounter will be assigned FALSE.
* (The high edges will be checked eventually by a call to the
* ipset_bdd_iterator_advance() function.)
*/
static void
add_node(struct ipset_bdd_iterator *iterator, ipset_node_id node_id)
{
/* Keep tracing down low edges until we reach a terminal. */
while (ipset_node_get_type(node_id) == IPSET_NONTERMINAL_NODE) {
/* Add this nonterminal node to the stack, and trace down
* further into the tree. We check low edges first, so set the
* node's variable to FALSE in the assignment. */
struct ipset_node *node =
ipset_node_cache_get_nonterminal(iterator->cache, node_id);
cork_array_append(&iterator->stack, node_id);
ipset_assignment_set(iterator->assignment, node->variable, false);
node_id = node->low;
}
/* Once we find a terminal node, save it away in the iterator result
* and return. */
iterator->value = ipset_terminal_value(node_id);
}
struct ipset_bdd_iterator *
ipset_node_iterate(struct ipset_node_cache *cache, ipset_node_id root)
{
/* First allocate the iterator itself, and all of its contained
* fields. */
struct ipset_bdd_iterator *iterator =
cork_new(struct ipset_bdd_iterator);
iterator->finished = false;
iterator->cache = cache;
cork_array_init(&iterator->stack);
iterator->assignment = ipset_assignment_new();
/* Then add the root node to the iterator, tracing down until we
* find the first terminal node. */
add_node(iterator, root);
return iterator;
}
void
ipset_bdd_iterator_free(struct ipset_bdd_iterator *iterator)
{
cork_array_done(&iterator->stack);
ipset_assignment_free(iterator->assignment);
free(iterator);
}
void
ipset_bdd_iterator_advance(struct ipset_bdd_iterator *iterator)
{
/* If we're already at the end of the iterator, don't do anything. */
if (CORK_UNLIKELY(iterator->finished)) {
return;
}
/* We look at the last node in the stack. If it's currently
* assigned a false value, then we track down its true branch. If
* it's got a true branch, then we pop it off and check the next to
* last node. */
DEBUG("Advancing BDD iterator");
while (cork_array_size(&iterator->stack) > 0) {
ipset_node_id last_node_id =
cork_array_at
(&iterator->stack, cork_array_size(&iterator->stack) - 1);
struct ipset_node *last_node =
ipset_node_cache_get_nonterminal(iterator->cache, last_node_id);
enum ipset_tribool current_value =
ipset_assignment_get(iterator->assignment, last_node->variable);
/* The current value can't be EITHER, because we definitely
* assign a TRUE or FALSE to the variables of the nodes that we
* encounter. */
if (current_value == IPSET_TRUE) {
/* We've checked both outgoing edges for this node, so pop
* it off and look at its parent. */
iterator->stack.size--;
/* Before continuing, reset this node's variable to
* indeterminate in the assignment. */
ipset_assignment_set
(iterator->assignment, last_node->variable, IPSET_EITHER);
} else {
/* We've checked this node's low edge, but not its high
* edge. Set the variable to TRUE in the assignment, and
* add the high edge's node to the node stack. */
ipset_assignment_set
(iterator->assignment, last_node->variable, IPSET_TRUE);
add_node(iterator, last_node->high);
return;
}
}
/* If we fall through then we ran out of nodes to check. That means
* the iterator is done! */
iterator->finished = true;
}
|
281677160/openwrt-package | 1,649 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/include/ipset/bits.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef IPSET_BITS_H
#define IPSET_BITS_H
#include <libcork/core.h>
/*-----------------------------------------------------------------------
* Bit arrays
*/
/**
* Extract the byte that contains a particular bit in an array.
*/
#define IPSET_BIT_GET_BYTE(array, i) \
(((uint8_t *) (array))[(i) / 8])
/**
* Create a bit mask that extracts a particular bit from the byte that
* it lives in.
*/
#define IPSET_BIT_ON_MASK(i) \
(0x80 >> ((i) % 8))
/**
* Create a bit mask that extracts everything except for a particular
* bit from the byte that it lives in.
*/
#define IPSET_BIT_NEG_MASK(i) \
(~IPSET_BIT_ON_MASK(i))
/**
* Return whether a particular bit is set in a byte array. Bits are
* numbered from 0, in a big-endian order.
*/
#define IPSET_BIT_GET(array, i) \
((IPSET_BIT_GET_BYTE(array, i) & \
IPSET_BIT_ON_MASK(i)) != 0)
/**
* Set (or unset) a particular bit is set in a byte array. Bits are
* numbered from 0, in a big-endian order.
*/
#define IPSET_BIT_SET(array, i, val) \
(IPSET_BIT_GET_BYTE(array, i) = \
(IPSET_BIT_GET_BYTE(array, i) & IPSET_BIT_NEG_MASK(i)) \
| ((val)? IPSET_BIT_ON_MASK(i): 0))
#endif /* IPSET_BITS_H */
|
281677160/openwrt-package | 6,603 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/include/ipset/ipset.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2009-2012, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef IPSET_IPSET_H
#define IPSET_IPSET_H
#include <stdio.h>
#include <libcork/core.h>
#include <libcork/ds.h>
#include <ipset/bdd/nodes.h>
struct ip_set {
struct ipset_node_cache *cache;
ipset_node_id set_bdd;
};
struct ip_map {
struct ipset_node_cache *cache;
ipset_node_id map_bdd;
ipset_node_id default_bdd;
};
/*---------------------------------------------------------------------
* General functions
*/
int
ipset_init_library(void);
/*---------------------------------------------------------------------
* IP set functions
*/
void
ipset_init(struct ip_set *set);
void
ipset_done(struct ip_set *set);
struct ip_set *
ipset_new(void);
void
ipset_free(struct ip_set *set);
bool
ipset_is_empty(const struct ip_set *set);
bool
ipset_is_equal(const struct ip_set *set1, const struct ip_set *set2);
size_t
ipset_memory_size(const struct ip_set *set);
int
ipset_save(FILE *stream, const struct ip_set *set);
int
ipset_save_to_stream(struct cork_stream_consumer *stream,
const struct ip_set *set);
int
ipset_save_dot(FILE *stream, const struct ip_set *set);
struct ip_set *
ipset_load(FILE *stream);
bool
ipset_ipv4_add(struct ip_set *set, struct cork_ipv4 *elem);
bool
ipset_ipv4_add_network(struct ip_set *set, struct cork_ipv4 *elem,
unsigned int cidr_prefix);
bool
ipset_ipv4_remove(struct ip_set *set, struct cork_ipv4 *elem);
bool
ipset_ipv4_remove_network(struct ip_set *set, struct cork_ipv4 *elem,
unsigned int cidr_prefix);
bool
ipset_contains_ipv4(const struct ip_set *set, struct cork_ipv4 *elem);
bool
ipset_ipv6_add(struct ip_set *set, struct cork_ipv6 *elem);
bool
ipset_ipv6_add_network(struct ip_set *set, struct cork_ipv6 *elem,
unsigned int cidr_prefix);
bool
ipset_ipv6_remove(struct ip_set *set, struct cork_ipv6 *elem);
bool
ipset_ipv6_remove_network(struct ip_set *set, struct cork_ipv6 *elem,
unsigned int cidr_prefix);
bool
ipset_contains_ipv6(const struct ip_set *set, struct cork_ipv6 *elem);
bool
ipset_ip_add(struct ip_set *set, struct cork_ip *addr);
bool
ipset_ip_add_network(struct ip_set *set, struct cork_ip *addr,
unsigned int cidr_prefix);
bool
ipset_ip_remove(struct ip_set *set, struct cork_ip *addr);
bool
ipset_ip_remove_network(struct ip_set *set, struct cork_ip *addr,
unsigned int cidr_prefix);
bool
ipset_contains_ip(const struct ip_set *set, struct cork_ip *elem);
/* An internal state type used by the ipset_iterator_multiple_expansion_state
* field. */
enum ipset_iterator_state {
IPSET_ITERATOR_NORMAL = 0,
IPSET_ITERATOR_MULTIPLE_IPV4,
IPSET_ITERATOR_MULTIPLE_IPV6
};
/* An iterator that returns all of the IP addresses that have a given value in
* an IP set or map. */
struct ipset_iterator {
/* The address of the current IP network in the iterator. */
struct cork_ip addr;
/* The netmask of the current IP network in the iterator, given as a
* CIDR prefix. For a single IP address, this will be 32 or 128. */
unsigned int cidr_prefix;
/* Whether the current assignment needs to be expanded a second
* time.
*
* We have to expand IPv4 and IPv6 assignments separately, since the
* set of variables to turn into address bits is different.
* Unfortunately, a BDD assignment can contain both IPv4 and IPv6
* addresses, if variable 0 is EITHER. (This is trivially true for
* the empty set, for instance.) In this case, we have to
* explicitly set variable 0 to TRUE, expand it as IPv4, and then
* set it to FALSE, and expand it as IPv6. This variable tells us
* whether we're in an assignment that needs to be expanded twice,
* and if so, which expansion we're currently in.
*/
enum ipset_iterator_state multiple_expansion_state;
/* An iterator for retrieving each assignment in the set's BDD. */
struct ipset_bdd_iterator *bdd_iterator;
/* An iterator for expanding each assignment into individual IP
* addresses. */
struct ipset_expanded_assignment *assignment_iterator;
/* Whether there are any more IP addresses in this iterator. */
bool finished;
/* The desired value for each IP address. */
bool desired_value;
/* Whether to summarize the contents of the IP set as networks,
* where possible. */
bool summarize;
};
struct ipset_iterator *
ipset_iterate(struct ip_set *set, bool desired_value);
struct ipset_iterator *
ipset_iterate_networks(struct ip_set *set, bool desired_value);
void
ipset_iterator_free(struct ipset_iterator *iterator);
void
ipset_iterator_advance(struct ipset_iterator *iterator);
/*---------------------------------------------------------------------
* IP map functions
*/
void
ipmap_init(struct ip_map *map, int default_value);
void
ipmap_done(struct ip_map *map);
struct ip_map *
ipmap_new(int default_value);
void
ipmap_free(struct ip_map *map);
bool
ipmap_is_empty(const struct ip_map *map);
bool
ipmap_is_equal(const struct ip_map *map1, const struct ip_map *map2);
size_t
ipmap_memory_size(const struct ip_map *map);
int
ipmap_save(FILE *stream, const struct ip_map *map);
int
ipmap_save_to_stream(struct cork_stream_consumer *stream,
const struct ip_map *map);
struct ip_map *
ipmap_load(FILE *stream);
void
ipmap_ipv4_set(struct ip_map *map, struct cork_ipv4 *elem, int value);
void
ipmap_ipv4_set_network(struct ip_map *map, struct cork_ipv4 *elem,
unsigned int cidr_prefix, int value);
int
ipmap_ipv4_get(struct ip_map *map, struct cork_ipv4 *elem);
void
ipmap_ipv6_set(struct ip_map *map, struct cork_ipv6 *elem, int value);
void
ipmap_ipv6_set_network(struct ip_map *map, struct cork_ipv6 *elem,
unsigned int cidr_prefix, int value);
int
ipmap_ipv6_get(struct ip_map *map, struct cork_ipv6 *elem);
void
ipmap_ip_set(struct ip_map *map, struct cork_ip *addr, int value);
void
ipmap_ip_set_network(struct ip_map *map, struct cork_ip *addr,
unsigned int cidr_prefix, int value);
int
ipmap_ip_get(struct ip_map *map, struct cork_ip *addr);
#endif /* IPSET_IPSET_H */
|
281677160/openwrt-package | 14,883 | luci-app-ssr-plus/shadowsocksr-libev/src/libipset/include/ipset/bdd/nodes.h | /* -*- coding: utf-8 -*-
* ----------------------------------------------------------------------
* Copyright © 2010-2013, RedJack, LLC.
* All rights reserved.
*
* Please see the LICENSE.txt file in this distribution for license
* details.
* ----------------------------------------------------------------------
*/
#ifndef IPSET_BDD_NODES_H
#define IPSET_BDD_NODES_H
#include <stdio.h>
#include <libcork/core.h>
#include <libcork/ds.h>
/*-----------------------------------------------------------------------
* Preliminaries
*/
/**
* Each variable in a BDD is referred to by number.
*/
typedef unsigned int ipset_variable;
/**
* Each BDD terminal represents an integer value. The integer must be
* non-negative, but must be within the range of the <i>signed</i>
* integer type.
*/
typedef unsigned int ipset_value;
/**
* An identifier for each distinct node in a BDD.
*
* Internal implementation note. Since pointers are aligned to at
* least two bytes, the ID of a terminal node has its LSB set to 1,
* and has the terminal value stored in the remaining bits. The ID of
* a nonterminal node is simply a pointer to the node struct.
*/
typedef unsigned int ipset_node_id;
/**
* Nodes can either be terminal or nonterminal.
*/
enum ipset_node_type {
IPSET_NONTERMINAL_NODE = 0,
IPSET_TERMINAL_NODE = 1
};
/**
* Return the type of node represented by a particular node ID.
*/
#define ipset_node_get_type(node_id) ((node_id) & 0x01)
#define IPSET_NODE_ID_FORMAT "%s%u"
#define IPSET_NODE_ID_VALUES(node_id) \
(ipset_node_get_type((node_id)) == IPSET_NONTERMINAL_NODE? "s": ""), \
((node_id) >> 1)
/*-----------------------------------------------------------------------
* Terminal nodes
*/
/**
* Return the value of a terminal node. The result is undefined if
* the node ID represents a nonterminal.
*/
#define ipset_terminal_value(node_id) ((node_id) >> 1)
/**
* Creates a terminal node ID from a terminal value.
*/
#define ipset_terminal_node_id(value) \
(((value) << 1) | IPSET_TERMINAL_NODE)
/*-----------------------------------------------------------------------
* Nonterminal nodes
*/
/**
* A nonterminal BDD node. This is an inner node of the BDD tree.
* The node represents one variable in an overall variable assignment.
* The node has two children: a “low” child and a “high” child. The
* low child is the subtree that applies when the node's variable is
* false or 0; the high child is the subtree that applies when it's
* true or 1.
*
* This type does not take care of ensuring that all BDD nodes are
* reduced; that is handled by the node_cache class.
*/
struct ipset_node {
/** The reference count for this node. */
unsigned int refcount;
/** The variable that this node represents. */
ipset_variable variable;
/** The subtree node for when the variable is false. */
ipset_node_id low;
/** The subtree node for when the variable is true. */
ipset_node_id high;
};
/**
* Return the "value" of a nonterminal node. The value of a nonterminal
* is the index into the node array of the cache that the node belongs
* to.
*/
#define ipset_nonterminal_value(node_id) ((node_id) >> 1)
/**
* Creates a nonterminal node ID from a nonterminal value.
*/
#define ipset_nonterminal_node_id(value) \
(((value) << 1) | IPSET_NONTERMINAL_NODE)
/**
* Print out a node object.
*/
void
ipset_node_fprint(FILE *stream, struct ipset_node *node);
/*-----------------------------------------------------------------------
* Node caches
*/
/**
* The log2 of the size of each chunk of BDD nodes.
*/
/* 16K elements per cache */
#define IPSET_BDD_NODE_CACHE_BIT_SIZE 6
#define IPSET_BDD_NODE_CACHE_SIZE (1 << IPSET_BDD_NODE_CACHE_BIT_SIZE)
#define IPSET_BDD_NODE_CACHE_MASK (IPSET_BDD_NODE_CACHE_SIZE - 1)
/**
* A cache for BDD nodes. By creating and retrieving nodes through
* the cache, we ensure that a BDD is reduced.
*/
struct ipset_node_cache {
/** The storage for the nodes managed by this cache. */
cork_array(struct ipset_node *) chunks;
/** The largest nonterminal index that has been handed out. */
ipset_value largest_index;
/** The index of the first node in the free list. */
ipset_value free_list;
/** A cache of the nonterminal nodes, keyed by their contents. */
struct cork_hash_table *node_cache;
};
/**
* Returns the index of the chunk that the given nonterminal lives in.
*/
#define ipset_nonterminal_chunk_index(index) \
((index) >> IPSET_BDD_NODE_CACHE_BIT_SIZE)
/**
* Returns the offset of the given nonterminal within its chunk.
*/
#define ipset_nonterminal_chunk_offset(index) \
((index) & IPSET_BDD_NODE_CACHE_MASK)
/**
* Returns a pointer to the ipset_node for a given nonterminal index.
*/
#define ipset_node_cache_get_nonterminal_by_index(cache, index) \
(&cork_array_at(&(cache)->chunks, ipset_nonterminal_chunk_index((index))) \
[ipset_nonterminal_chunk_offset((index))])
/**
* Returns the ipset_node for a given nonterminal node ID.
*/
#define ipset_node_cache_get_nonterminal(cache, node_id) \
(ipset_node_cache_get_nonterminal_by_index \
((cache), ipset_nonterminal_value((node_id))))
/**
* Create a new node cache.
*/
struct ipset_node_cache *
ipset_node_cache_new(void);
/**
* Free a node cache.
*/
void
ipset_node_cache_free(struct ipset_node_cache *cache);
/**
* Create a new nonterminal node with the given contents, returning
* its ID. This function ensures that there is only one node with the
* given contents in this cache.
*
* Steals references to low and high.
*/
ipset_node_id
ipset_node_cache_nonterminal(struct ipset_node_cache *cache,
ipset_variable variable,
ipset_node_id low, ipset_node_id high);
/**
* Increment the reference count of a nonterminal node. (This is a
* no-op for terminal nodes.)
*/
ipset_node_id
ipset_node_incref(struct ipset_node_cache *cache, ipset_node_id node);
/**
* Decrement the reference count of a nonterminal node. If the
* reference count reaches 0, the storage for the node will be
* reclaimed. (This is a no-op for terminal nodes.)
*/
void
ipset_node_decref(struct ipset_node_cache *cache, ipset_node_id node);
/**
* Return the number of nodes that are reachable from the given node.
* This does not include duplicates if a node is reachable via more
* than one path.
*/
size_t
ipset_node_reachable_count(const struct ipset_node_cache *cache,
ipset_node_id node);
/**
* Return the amount of memory used by the nodes in the given BDD.
*/
size_t
ipset_node_memory_size(const struct ipset_node_cache *cache,
ipset_node_id node);
/**
* Load a BDD from an input stream. The error field is filled in with
* an error condition is the BDD can't be read for any reason.
*/
ipset_node_id
ipset_node_cache_load(FILE *stream, struct ipset_node_cache *cache);
/**
* Save a BDD to an output stream. This encodes the set using only
* those nodes that are reachable from the BDD's root node.
*/
int
ipset_node_cache_save(struct cork_stream_consumer *stream,
struct ipset_node_cache *cache, ipset_node_id node);
/**
* Compare two BDD nodes, possibly from different caches, for equality.
*/
bool
ipset_node_cache_nodes_equal(const struct ipset_node_cache *cache1,
ipset_node_id node1,
const struct ipset_node_cache *cache2,
ipset_node_id node2);
/**
* Save a GraphViz dot graph for a BDD. The graph script is written
* to the given output stream. This graph only includes those nodes
* that are reachable from the BDD's root node.
*/
int
ipset_node_cache_save_dot(struct cork_stream_consumer *stream,
struct ipset_node_cache *cache, ipset_node_id node);
/*-----------------------------------------------------------------------
* BDD operators
*/
/**
* A function that provides the value for each variable in a BDD.
*/
typedef bool
(*ipset_assignment_func)(const void *user_data,
ipset_variable variable);
/**
* An assignment function that gets the variable values from an array
* of gbooleans.
*/
bool
ipset_bool_array_assignment(const void *user_data,
ipset_variable variable);
/**
* An assignment function that gets the variable values from an array
* of bits.
*/
bool
ipset_bit_array_assignment(const void *user_data,
ipset_variable variable);
/**
* Evaluate a BDD given a particular assignment of variables.
*/
ipset_value
ipset_node_evaluate(const struct ipset_node_cache *cache, ipset_node_id node,
ipset_assignment_func assignment,
const void *user_data);
/**
* Add an assignment to the BDD.
*/
ipset_node_id
ipset_node_insert(struct ipset_node_cache *cache, ipset_node_id node,
ipset_assignment_func assignment,
const void *user_data, ipset_variable variable_count,
ipset_value value);
/*-----------------------------------------------------------------------
* Variable assignments
*/
/**
* Each variable in the input to a Boolean function can be true or
* false; it can also be EITHER, which means that the variable can be
* either true or false in a particular assignment without affecting
* the result of the function.
*/
enum ipset_tribool {
IPSET_FALSE = 0,
IPSET_TRUE = 1,
IPSET_EITHER = 2
};
/**
* An assignment is a mapping of variable numbers to Boolean values.
* It represents an input to a Boolean function that maps to a
* particular output value. Each variable in the input to a Boolean
* function can be true or false; it can also be EITHER, which means
* that the variable can be either true or false in a particular
* assignment without affecting the result of the function.
*/
struct ipset_assignment {
/**
* The underlying variable assignments are stored in a vector of
* tribools. Every variable that has a true or false value must
* appear in the vector. Variables that are EITHER only have to
* appear to prevent gaps in the vector. Any variables outside
* the range of the vector are assumed to be EITHER.
*/
cork_array(enum ipset_tribool) values;
};
/**
* Create a new assignment where all variables are indeterminite.
*/
struct ipset_assignment *
ipset_assignment_new();
/**
* Free an assignment.
*/
void
ipset_assignment_free(struct ipset_assignment *assignment);
/**
* Compare two assignments for equality.
*/
bool
ipset_assignment_equal(const struct ipset_assignment *assignment1,
const struct ipset_assignment *assignment2);
/**
* Set the given variable, and all higher variables, to the EITHER
* value.
*/
void
ipset_assignment_cut(struct ipset_assignment *assignment, ipset_variable var);
/**
* Clear the assignment, setting all variables to the EITHER value.
*/
void
ipset_assignment_clear(struct ipset_assignment *assignment);
/**
* Return the value assigned to a particular variable.
*/
enum ipset_tribool
ipset_assignment_get(struct ipset_assignment *assignment, ipset_variable var);
/**
* Set the value assigned to a particular variable.
*/
void
ipset_assignment_set(struct ipset_assignment *assignment,
ipset_variable var, enum ipset_tribool value);
/*-----------------------------------------------------------------------
* Expanded assignments
*/
/**
* An iterator for expanding a variable assignment. For each EITHER
* variable in the assignment, the iterator yields a result with both
* values.
*/
struct ipset_expanded_assignment {
/** Whether there are any more assignments in this iterator. */
bool finished;
/**
* The variable values in the current expanded assignment. Since
* there won't be any EITHERs in the expanded assignment, we can
* use a byte array, and represent each variable by a single bit.
*/
struct cork_buffer values;
/**
* An array containing all of the variables that are EITHER in the
* original assignment.
*/
cork_array(ipset_variable) eithers;
};
/**
* Return an iterator that expands a variable assignment. For each
* variable that's EITHER in the assignment, the iterator yields a
* result with both values. The iterator will ensure that the
* specified number of variables are given concrete values.
*/
struct ipset_expanded_assignment *
ipset_assignment_expand(const struct ipset_assignment *assignment,
ipset_variable var_count);
/**
* Free an expanded assignment iterator.
*/
void
ipset_expanded_assignment_free(struct ipset_expanded_assignment *exp);
/**
* Advance the iterator to the next assignment.
*/
void
ipset_expanded_assignment_advance(struct ipset_expanded_assignment *exp);
/*-----------------------------------------------------------------------
* BDD iterators
*/
/**
* An iterator for walking through the assignments for a given BDD
* node.
*
* The iterator walks through each path in the BDD tree, stopping at
* each terminal node. Each time we reach a terminal node, we yield a
* new ipset_assignment object representing the assignment of variables
* along the current path.
*
* We maintain a stack of nodes leading to the current terminal, which
* allows us to backtrack up the path to find the next terminal when
* we increment the iterator.
*/
struct ipset_bdd_iterator {
/** Whether there are any more assignments in this iterator. */
bool finished;
/** The node cache that we're iterating through. */
struct ipset_node_cache *cache;
/**
* The sequence of nonterminal nodes leading to the current
* terminal.
*/
cork_array(ipset_node_id) stack;
/** The current assignment. */
struct ipset_assignment *assignment;
/**
* The value of the BDD's function when applied to the current
* assignment.
*/
ipset_value value;
};
/**
* Return an iterator that yields all of the assignments in the given
* BDD. The iterator contains two items of interest. The first is an
* ipset_assignment providing the value that each variable takes, while
* the second is the terminal value that is the result of the BDD's
* function when applied to that variable assignment.
*/
struct ipset_bdd_iterator *
ipset_node_iterate(struct ipset_node_cache *cache, ipset_node_id root);
/**
* Free a BDD iterator.
*/
void
ipset_bdd_iterator_free(struct ipset_bdd_iterator *iterator);
/**
* Advance the iterator to the next assignment.
*/
void
ipset_bdd_iterator_advance(struct ipset_bdd_iterator *iterator);
#endif /* IPSET_BDD_NODES_H */
|
281677160/openwrt-package | 2,233 | luci-app-ssr-plus/shadowsocksr-libev/src/rpm/SOURCES/etc/init.d/shadowsocks-libev | #!/bin/bash
#
# Script to run Shadowsocks in daemon mode at boot time.
# ScriptAuthor: icyboy
# Revision 1.0 - 14th Sep 2013
#====================================================================
# Run level information:
# chkconfig: 2345 99 99
# Description: lightweight secured socks5 proxy
# processname: ss-server
# Author: Max Lv <max.c.lv@gmail.com>;
# Run "/sbin/chkconfig --add shadowsocks" to add the Run levels.
#====================================================================
#====================================================================
# Paths and variables and system checks.
# Source function library
. /etc/rc.d/init.d/functions
# Check that networking is up.
#
[ ${NETWORKING} ="yes" ] || exit 0
# Daemon
NAME=shadowsocks-server
DAEMON=/usr/bin/ss-server
# Path to the configuration file.
#
CONF=/etc/shadowsocks-libev/config.json
#USER="nobody"
#GROUP="nobody"
# Take care of pidfile permissions
mkdir /var/run/$NAME 2>/dev/null || true
#chown "$USER:$GROUP" /var/run/$NAME
# Check the configuration file exists.
#
if [ ! -f $CONF ] ; then
echo "The configuration file cannot be found!"
exit 0
fi
# Path to the lock file.
#
LOCK_FILE=/var/lock/subsys/shadowsocks
# Path to the pid file.
#
PID=/var/run/$NAME/pid
#====================================================================
#====================================================================
# Run controls:
RETVAL=0
# Start shadowsocks as daemon.
#
start() {
if [ -f $LOCK_FILE ]; then
echo "$NAME is already running!"
exit 0
else
echo -n $"Starting ${NAME}: "
#daemon --check $DAEMON --user $USER "$DAEMON -f $PID -c $CONF > /dev/null"
daemon $DAEMON -u -c $CONF -f $PID
fi
RETVAL=$?
[ $RETVAL -eq 0 ] && success
echo
[ $RETVAL -eq 0 ] && touch $LOCK_FILE
return $RETVAL
}
# Stop shadowsocks.
#
stop() {
echo -n $"Shutting down ${NAME}: "
killproc -p ${PID}
RETVAL=$?
[ $RETVAL -eq 0 ]
rm -f $LOCK_FILE
rm -f ${PID}
echo
return $RETVAL
}
# See how we were called.
case "$1" in
start)
start
;;
stop)
stop
;;
restart)
stop
start
;;
condrestart)
if [ -f $LOCK_FILE ]; then
stop
start
RETVAL=$?
fi
;;
status)
status $DAEMON
RETVAL=$?
;;
*)
echo $"Usage: $0 {start|stop|restart|condrestart|status}"
RETVAL=1
esac
exit $RETVAL
|
281677160/openwrt-package | 2,779 | luci-app-ssr-plus/shadowsocksr-libev/src/src/obfs/crc32.c | #include <stdlib.h>
#include <stdint.h>
#include "crc32.h"
static uint32_t crc32_table[256] = {0};
void init_crc32_table(void) {
uint32_t c, i, j;
if (crc32_table[0] == 0) {
for (i = 0; i < 256; i++) {
c = i;
for (j = 0; j < 8; j++) {
if (c & 1)
c = 0xedb88320L ^ (c >> 1);
else
c = c >> 1;
}
crc32_table[i] = c;
}
}
}
uint32_t crc32(unsigned char *buffer, unsigned int size) {
uint32_t crc = 0xFFFFFFFF;
unsigned int i;
for (i = 0; i < size; i++) {
crc = crc32_table[(crc ^ buffer[i]) & 0xFF] ^ (crc >> 8);
}
return crc ^ 0xFFFFFFFF;
}
void fillcrc32to(unsigned char *buffer, unsigned int size, unsigned char *outbuffer) {
uint32_t crc = 0xFFFFFFFF;
unsigned int i;
for (i = 0; i < size; i++) {
crc = crc32_table[(crc ^ buffer[i]) & 0xff] ^ (crc >> 8);
}
crc ^= 0xFFFFFFFF;
outbuffer[0] = (unsigned char)crc;
outbuffer[1] = (unsigned char)(crc >> 8);
outbuffer[2] = (unsigned char)(crc >> 16);
outbuffer[3] = (unsigned char)(crc >> 24);
}
void fillcrc32(unsigned char *buffer, unsigned int size) {
uint32_t crc = 0xFFFFFFFF;
unsigned int i;
size -= 4;
for (i = 0; i < size; i++) {
crc = crc32_table[(crc ^ buffer[i]) & 0xff] ^ (crc >> 8);
}
buffer += size;
buffer[0] = (unsigned char)crc;
buffer[1] = (unsigned char)(crc >> 8);
buffer[2] = (unsigned char)(crc >> 16);
buffer[3] = (unsigned char)(crc >> 24);
}
void adler32_short(unsigned char *buffer, unsigned int size, uint32_t *a, uint32_t *b) {
for (int i = 0; i < (int)size; i++) {
*a += buffer[i];
*b += *a;
}
*a %= 65521;
*b %= 65521;
}
#define NMAX 5552
uint32_t adler32(unsigned char *buffer, unsigned int size) {
uint32_t a = 1;
uint32_t b = 0;
while ( size >= NMAX ) {
adler32_short(buffer, NMAX, &a, &b);
buffer += NMAX;
size -= NMAX;
}
adler32_short(buffer, size, &a, &b);
return (b << 16) + a;
}
#undef NMAX
void filladler32(unsigned char *buffer, unsigned int size) {
size -= 4;
uint32_t checksum = adler32(buffer, size);
buffer += size;
buffer[0] = (unsigned char)checksum;
buffer[1] = (unsigned char)(checksum >> 8);
buffer[2] = (unsigned char)(checksum >> 16);
buffer[3] = (unsigned char)(checksum >> 24);
}
int checkadler32(unsigned char *buffer, unsigned int size) {
size -= 4;
uint32_t checksum = adler32(buffer, size);
buffer += size;
return checksum == (((uint32_t)buffer[3] << 24)
| ((uint32_t)buffer[2] << 16)
| ((uint32_t)buffer[1] << 8)
| (uint32_t)buffer[0]);
}
|
281677160/openwrt-package | 11,948 | luci-app-ssr-plus/shadowsocksr-libev/src/src/obfs/obfs.c | #include <string.h>
#include <stdlib.h>
#include "obfs.h"
int rand_bytes(uint8_t *output, int len);
#include "obfsutil.h"
#include "crc32.h"
#include "http_simple.h"
#include "tls1.2_ticket.h"
#include "verify.h"
#include "auth.h"
#include "auth_chain.h"
#include "../utils.h"
void *init_data() {
return malloc(1);
}
obfs *new_obfs() {
obfs *self = (obfs *) malloc(sizeof(obfs));
self->l_data = NULL;
return self;
}
int get_overhead(obfs *self) {
return 0;
}
void set_server_info(obfs *self, server_info *server) {
memmove(&self->server, server, sizeof(server_info));
}
void get_server_info(obfs *self, server_info *server) {
memmove(server, &self->server, sizeof(server_info));
}
void dispose_obfs(obfs *self) {
free(self);
}
obfs_class *new_obfs_class(const char *plugin_name) {
if (plugin_name == NULL)
return NULL;
if (strcmp(plugin_name, "origin") == 0)
return NULL;
if (strcmp(plugin_name, "plain") == 0)
return NULL;
init_crc32_table();
init_shift128plus();
if (strcmp(plugin_name, "http_simple") == 0) {
obfs_class *plugin = (obfs_class *) malloc(sizeof(obfs_class));
plugin->init_data = init_data;
plugin->new_obfs = http_simple_new_obfs;
plugin->get_overhead = get_overhead;
plugin->get_server_info = get_server_info;
plugin->set_server_info = set_server_info;
plugin->dispose = http_simple_dispose;
plugin->client_encode = http_simple_client_encode;
plugin->client_decode = http_simple_client_decode;
return plugin;
} else if (strcmp(plugin_name, "http_post") == 0) {
obfs_class *plugin = (obfs_class *) malloc(sizeof(obfs_class));
plugin->init_data = init_data;
plugin->new_obfs = http_simple_new_obfs;
plugin->get_overhead = get_overhead;
plugin->get_server_info = get_server_info;
plugin->set_server_info = set_server_info;
plugin->dispose = http_simple_dispose;
plugin->client_encode = http_post_client_encode;
plugin->client_decode = http_simple_client_decode;
return plugin;
} else if (strcmp(plugin_name, "tls1.2_ticket_auth") == 0) {
obfs_class *plugin = (obfs_class *) malloc(sizeof(obfs_class));
plugin->init_data = tls12_ticket_auth_init_data;
plugin->new_obfs = tls12_ticket_auth_new_obfs;
plugin->get_overhead = tls12_ticket_auth_get_overhead;
plugin->get_server_info = get_server_info;
plugin->set_server_info = set_server_info;
plugin->dispose = tls12_ticket_auth_dispose;
plugin->client_encode = tls12_ticket_auth_client_encode;
plugin->client_decode = tls12_ticket_auth_client_decode;
return plugin;
/*} else if (strcmp(plugin_name, "verify_simple") == 0) {
obfs_class * plugin = (obfs_class*)malloc(sizeof(obfs_class));
plugin->init_data = init_data;
plugin->new_obfs = verify_simple_new_obfs;
plugin->get_server_info = get_server_info;
plugin->set_server_info = set_server_info;
plugin->dispose = verify_simple_dispose;
plugin->client_pre_encrypt = verify_simple_client_pre_encrypt;
plugin->client_post_decrypt = verify_simple_client_post_decrypt;
plugin->client_udp_pre_encrypt = NULL;
plugin->client_udp_post_decrypt = NULL;
return plugin;
} else if (strcmp(plugin_name, "auth_simple") == 0) {
obfs_class * plugin = (obfs_class*)malloc(sizeof(obfs_class));
plugin->init_data = auth_simple_init_data;
plugin->new_obfs = auth_simple_new_obfs;
plugin->get_server_info = get_server_info;
plugin->set_server_info = set_server_info;
plugin->dispose = auth_simple_dispose;
plugin->client_pre_encrypt = auth_simple_client_pre_encrypt;
plugin->client_post_decrypt = auth_simple_client_post_decrypt;
plugin->client_udp_pre_encrypt = NULL;
plugin->client_udp_post_decrypt = NULL;
return plugin;*/
} else if (strcmp(plugin_name, "auth_sha1") == 0) {
obfs_class *plugin = (obfs_class *) malloc(sizeof(obfs_class));
plugin->init_data = auth_simple_init_data;
plugin->new_obfs = auth_simple_new_obfs;
plugin->get_overhead = get_overhead;
plugin->get_server_info = get_server_info;
plugin->set_server_info = set_server_info;
plugin->dispose = auth_simple_dispose;
plugin->client_pre_encrypt = auth_sha1_client_pre_encrypt;
plugin->client_post_decrypt = auth_sha1_client_post_decrypt;
plugin->client_udp_pre_encrypt = NULL;
plugin->client_udp_post_decrypt = NULL;
return plugin;
} else if (strcmp(plugin_name, "auth_sha1_v2") == 0) {
obfs_class *plugin = (obfs_class *) malloc(sizeof(obfs_class));
plugin->init_data = auth_simple_init_data;
plugin->new_obfs = auth_simple_new_obfs;
plugin->get_overhead = get_overhead;
plugin->get_server_info = get_server_info;
plugin->set_server_info = set_server_info;
plugin->dispose = auth_simple_dispose;
plugin->client_pre_encrypt = auth_sha1_v2_client_pre_encrypt;
plugin->client_post_decrypt = auth_sha1_v2_client_post_decrypt;
plugin->client_udp_pre_encrypt = NULL;
plugin->client_udp_post_decrypt = NULL;
return plugin;
} else if (strcmp(plugin_name, "auth_sha1_v4") == 0) {
obfs_class *plugin = (obfs_class *) malloc(sizeof(obfs_class));
plugin->init_data = auth_simple_init_data;
plugin->new_obfs = auth_simple_new_obfs;
plugin->get_overhead = get_overhead;
plugin->get_server_info = get_server_info;
plugin->set_server_info = set_server_info;
plugin->dispose = auth_simple_dispose;
plugin->client_pre_encrypt = auth_sha1_v4_client_pre_encrypt;
plugin->client_post_decrypt = auth_sha1_v4_client_post_decrypt;
plugin->client_udp_pre_encrypt = NULL;
plugin->client_udp_post_decrypt = NULL;
return plugin;
} else if (strcmp(plugin_name, "auth_aes128_md5") == 0 || strcmp(plugin_name, "auth_aes128_sha1") == 0) {
obfs_class *plugin = (obfs_class *) malloc(sizeof(obfs_class));
plugin->init_data = auth_simple_init_data;
plugin->new_obfs = strcmp(plugin_name, "auth_aes128_md5") == 0 ?
auth_aes128_md5_new_obfs : auth_aes128_sha1_new_obfs;
plugin->get_overhead = auth_aes128_sha1_get_overhead;
plugin->get_server_info = get_server_info;
plugin->set_server_info = set_server_info;
plugin->dispose = auth_simple_dispose;
plugin->client_pre_encrypt = auth_aes128_sha1_client_pre_encrypt;
plugin->client_post_decrypt = auth_aes128_sha1_client_post_decrypt;
plugin->client_udp_pre_encrypt = auth_aes128_sha1_client_udp_pre_encrypt;
plugin->client_udp_post_decrypt = auth_aes128_sha1_client_udp_post_decrypt;
return plugin;
} else if (strcmp(plugin_name, "auth_chain_a") == 0) {
obfs_class *plugin = (obfs_class *) malloc(sizeof(obfs_class));
plugin->init_data = auth_chain_a_init_data;
plugin->new_obfs = auth_chain_a_new_obfs;
plugin->get_overhead = auth_chain_a_get_overhead;
plugin->get_server_info = get_server_info;
plugin->set_server_info = auth_chain_a_set_server_info;
plugin->dispose = auth_chain_a_dispose;
plugin->client_pre_encrypt = auth_chain_a_client_pre_encrypt;
plugin->client_post_decrypt = auth_chain_a_client_post_decrypt;
plugin->client_udp_pre_encrypt = auth_chain_a_client_udp_pre_encrypt;
plugin->client_udp_post_decrypt = auth_chain_a_client_udp_post_decrypt;
return plugin;
} else if (strcmp(plugin_name, "auth_chain_b") == 0) {
obfs_class *plugin = (obfs_class *) malloc(sizeof(obfs_class));
plugin->init_data = auth_chain_b_init_data;
plugin->new_obfs = auth_chain_b_new_obfs;
plugin->get_overhead = auth_chain_b_get_overhead;
plugin->get_server_info = get_server_info;
plugin->set_server_info = auth_chain_b_set_server_info;
plugin->dispose = auth_chain_b_dispose;
plugin->client_pre_encrypt = auth_chain_a_client_pre_encrypt;
plugin->client_post_decrypt = auth_chain_a_client_post_decrypt;
plugin->client_udp_pre_encrypt = auth_chain_a_client_udp_pre_encrypt;
plugin->client_udp_post_decrypt = auth_chain_a_client_udp_post_decrypt;
return plugin;
} else if (strcmp(plugin_name, "auth_chain_c") == 0) {
obfs_class *plugin = (obfs_class *) malloc(sizeof(obfs_class));
plugin->init_data = auth_chain_c_init_data;
plugin->new_obfs = auth_chain_c_new_obfs;
plugin->get_overhead = auth_chain_c_get_overhead;
plugin->get_server_info = get_server_info;
plugin->set_server_info = auth_chain_c_set_server_info;
plugin->dispose = auth_chain_c_dispose;
plugin->client_pre_encrypt = auth_chain_a_client_pre_encrypt;
plugin->client_post_decrypt = auth_chain_a_client_post_decrypt;
plugin->client_udp_pre_encrypt = auth_chain_a_client_udp_pre_encrypt;
plugin->client_udp_post_decrypt = auth_chain_a_client_udp_post_decrypt;
return plugin;
} else if (strcmp(plugin_name, "auth_chain_d") == 0) {
obfs_class *plugin = (obfs_class *) malloc(sizeof(obfs_class));
plugin->init_data = auth_chain_d_init_data;
plugin->new_obfs = auth_chain_d_new_obfs;
plugin->get_overhead = auth_chain_d_get_overhead;
plugin->get_server_info = get_server_info;
plugin->set_server_info = auth_chain_d_set_server_info;
plugin->dispose = auth_chain_d_dispose;
plugin->client_pre_encrypt = auth_chain_a_client_pre_encrypt;
plugin->client_post_decrypt = auth_chain_a_client_post_decrypt;
plugin->client_udp_pre_encrypt = auth_chain_a_client_udp_pre_encrypt;
plugin->client_udp_post_decrypt = auth_chain_a_client_udp_post_decrypt;
return plugin;
} else if (strcmp(plugin_name, "auth_chain_e") == 0) {
obfs_class *plugin = (obfs_class *) malloc(sizeof(obfs_class));
plugin->init_data = auth_chain_e_init_data;
plugin->new_obfs = auth_chain_e_new_obfs;
plugin->get_overhead = auth_chain_e_get_overhead;
plugin->get_server_info = get_server_info;
plugin->set_server_info = auth_chain_e_set_server_info;
plugin->dispose = auth_chain_e_dispose;
plugin->client_pre_encrypt = auth_chain_a_client_pre_encrypt;
plugin->client_post_decrypt = auth_chain_a_client_post_decrypt;
plugin->client_udp_pre_encrypt = auth_chain_a_client_udp_pre_encrypt;
plugin->client_udp_post_decrypt = auth_chain_a_client_udp_post_decrypt;
return plugin;
} else if (strcmp(plugin_name, "auth_chain_f") == 0) {
obfs_class *plugin = (obfs_class *) malloc(sizeof(obfs_class));
plugin->init_data = auth_chain_f_init_data;
plugin->new_obfs = auth_chain_f_new_obfs;
plugin->get_overhead = auth_chain_f_get_overhead;
plugin->get_server_info = get_server_info;
plugin->set_server_info = auth_chain_f_set_server_info;
plugin->dispose = auth_chain_f_dispose;
plugin->client_pre_encrypt = auth_chain_a_client_pre_encrypt;
plugin->client_post_decrypt = auth_chain_a_client_post_decrypt;
plugin->client_udp_pre_encrypt = auth_chain_a_client_udp_pre_encrypt;
plugin->client_udp_post_decrypt = auth_chain_a_client_udp_post_decrypt;
return plugin;
}
LOGE("Load obfs '%s' failed", plugin_name);
return NULL;
}
void free_obfs_class(obfs_class *plugin) {
free(plugin);
}
|
281677160/openwrt-package | 2,078 | luci-app-ssr-plus/shadowsocksr-libev/src/src/obfs/obfs.h | /*
* obfs.h - Define shadowsocksR server's buffers and callbacks
*
* Copyright (C) 2015 - 2016, Break Wa11 <mmgac001@gmail.com>
*/
#ifndef _OBFS_OBFS_H
#define _OBFS_OBFS_H
#include <stdint.h>
#include <unistd.h>
#include "encrypt.h"
#define OBFS_HMAC_SHA1_LEN 10
typedef struct {
char host[256];
uint16_t port;
char *param;
void *g_data;
uint8_t *iv;
uint16_t iv_len;
uint8_t *recv_iv;
uint16_t recv_iv_len;
uint8_t *key;
uint16_t key_len;
int head_len;
uint16_t tcp_mss;
uint16_t overhead;
uint32_t buffer_size;
cipher_env_t *cipher_env;
}server_info;
typedef struct {
server_info server;
void *l_data;
}obfs;
typedef struct {
void * (*init_data)();
obfs * (*new_obfs)();
int (*get_overhead)(obfs *self);
void (*get_server_info)(obfs *self, server_info *server);
void (*set_server_info)(obfs *self, server_info *server);
void (*dispose)(obfs *self);
int (*client_pre_encrypt)(obfs *self,
char **pplaindata,
int datalength,
size_t* capacity);
int (*client_encode)(obfs *self,
char **pencryptdata,
int datalength,
size_t* capacity);
int (*client_decode)(obfs *self,
char **pencryptdata,
int datalength,
size_t* capacity,
int *needsendback);
int (*client_post_decrypt)(obfs *self,
char **pplaindata,
int datalength,
size_t* capacity);
int (*client_udp_pre_encrypt)(obfs *self,
char **pplaindata,
int datalength,
size_t* capacity);
int (*client_udp_post_decrypt)(obfs *self,
char **pplaindata,
int datalength,
size_t* capacity);
}obfs_class;
obfs_class * new_obfs_class(const char *plugin_name);
void free_obfs_class(obfs_class *plugin);
void set_server_info(obfs *self, server_info *server);
void get_server_info(obfs *self, server_info *server);
obfs * new_obfs();
void dispose_obfs(obfs *self);
#endif // _OBFS_OBFS_H
|
281677160/openwrt-package | 1,697 | luci-app-ssr-plus/shadowsocksr-libev/src/src/obfs/auth.h | /*
* auth.h - Define shadowsocksR server's buffers and callbacks
*
* Copyright (C) 2015 - 2016, Break Wa11 <mmgac001@gmail.com>
*/
#ifndef _OBFS_AUTH_H
#define _OBFS_AUTH_H
#include "obfs.h"
void * auth_simple_init_data();
obfs * auth_simple_new_obfs();
obfs * auth_aes128_md5_new_obfs();
obfs * auth_aes128_sha1_new_obfs();
void auth_simple_dispose(obfs *self);
//int auth_simple_client_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity);
//int auth_simple_client_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity);
int auth_sha1_client_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity);
int auth_sha1_client_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity);
int auth_sha1_v2_client_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity);
int auth_sha1_v2_client_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity);
int auth_sha1_v4_client_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity);
int auth_sha1_v4_client_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity);
int auth_aes128_sha1_client_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity);
int auth_aes128_sha1_client_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity);
int auth_aes128_sha1_client_udp_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity);
int auth_aes128_sha1_client_udp_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity);
int auth_aes128_sha1_get_overhead(obfs *self);
#endif // _OBFS_AUTH_H
|
281677160/openwrt-package | 3,686 | luci-app-ssr-plus/shadowsocksr-libev/src/src/obfs/base64.c | #include "base64.h"
/* BASE 64 encode table */
static const char base64en[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
#define BASE64_PAD '='
#define BASE64DE_FIRST '+'
#define BASE64DE_LAST 'z'
/* ASCII order for BASE 64 decode, -1 in unused character */
static const signed char base64de[] = {
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
/* '+', ',', '-', '.', '/', */
-1, -1, -1, 62, -1, -1, -1, 63,
/* '0', '1', '2', '3', '4', '5', '6', '7', */
52, 53, 54, 55, 56, 57, 58, 59,
/* '8', '9', ':', ';', '<', '=', '>', '?', */
60, 61, -1, -1, -1, -1, -1, -1,
/* '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', */
-1, 0, 1, 2, 3, 4, 5, 6,
/* 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', */
7, 8, 9, 10, 11, 12, 13, 14,
/* 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', */
15, 16, 17, 18, 19, 20, 21, 22,
/* 'X', 'Y', 'Z', '[', '\', ']', '^', '_', */
23, 24, 25, -1, -1, -1, -1, -1,
/* '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', */
-1, 26, 27, 28, 29, 30, 31, 32,
/* 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', */
33, 34, 35, 36, 37, 38, 39, 40,
/* 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', */
41, 42, 43, 44, 45, 46, 47, 48,
/* 'x', 'y', 'z', */
49, 50, 51,
};
int
base64_encode(const unsigned char *in, unsigned int inlen, char *out)
{
unsigned int i, j;
for (i = j = 0; i < inlen; i++) {
int s = i % 3; /* from 6/gcd(6, 8) */
switch (s) {
case 0:
out[j++] = base64en[(in[i] >> 2) & 0x3F];
continue;
case 1:
out[j++] = base64en[((in[i-1] & 0x3) << 4) + ((in[i] >> 4) & 0xF)];
continue;
case 2:
out[j++] = base64en[((in[i-1] & 0xF) << 2) + ((in[i] >> 6) & 0x3)];
out[j++] = base64en[in[i] & 0x3F];
}
}
/* move back */
i -= 1;
/* check the last and add padding */
if ((i % 3) == 0) {
out[j++] = base64en[(in[i] & 0x3) << 4];
out[j++] = BASE64_PAD;
out[j++] = BASE64_PAD;
} else if ((i % 3) == 1) {
out[j++] = base64en[(in[i] & 0xF) << 2];
out[j++] = BASE64_PAD;
}
return BASE64_OK;
}
int
base64_decode(const char *in, unsigned int inlen, unsigned char *out)
{
unsigned int i, j;
for (i = j = 0; i < inlen; i++) {
int c;
int s = i % 4; /* from 8/gcd(6, 8) */
if (in[i] == '=')
return BASE64_OK;
if (in[i] < BASE64DE_FIRST || in[i] > BASE64DE_LAST ||
(c = base64de[(int)in[i]]) == -1)
return BASE64_INVALID;
switch (s) {
case 0:
out[j] = ((unsigned int)c << 2) & 0xFF;
continue;
case 1:
out[j++] += ((unsigned int)c >> 4) & 0x3;
/* if not last char with padding */
if (i < (inlen - 3) || in[inlen - 2] != '=')
out[j] = (unsigned char)(((unsigned int)c & 0xF) << 4);
continue;
case 2:
out[j++] += ((unsigned int)c >> 2) & 0xF;
/* if not last char with padding */
if (i < (inlen - 2) || in[inlen - 1] != '=')
out[j] = (unsigned char)(((unsigned int)c & 0x3) << 6);
continue;
case 3:
out[j++] += (unsigned char)c;
}
}
return BASE64_OK;
}
|
281677160/openwrt-package | 11,927 | luci-app-ssr-plus/shadowsocksr-libev/src/src/obfs/http_simple.c | #include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <time.h>
#include "http_simple.h"
#include "obfsutil.h"
static char* g_useragent[] = {
"Mozilla/5.0 (Windows NT 6.3; WOW64; rv:40.0) Gecko/20100101 Firefox/40.0",
"Mozilla/5.0 (Windows NT 6.3; WOW64; rv:40.0) Gecko/20100101 Firefox/44.0",
"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36",
"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.11 (KHTML, like Gecko) Ubuntu/11.10 Chromium/27.0.1453.93 Chrome/27.0.1453.93 Safari/537.36",
"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:35.0) Gecko/20100101 Firefox/35.0",
"Mozilla/5.0 (compatible; WOW64; MSIE 10.0; Windows NT 6.2)",
"Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US) AppleWebKit/533.20.25 (KHTML, like Gecko) Version/5.0.4 Safari/533.20.27",
"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.3; Trident/7.0; .NET4.0E; .NET4.0C)",
"Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko",
"Mozilla/5.0 (Linux; Android 4.4; Nexus 5 Build/BuildID) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/30.0.0.0 Mobile Safari/537.36",
"Mozilla/5.0 (iPad; CPU OS 5_0 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9A334 Safari/7534.48.3",
"Mozilla/5.0 (iPhone; CPU iPhone OS 5_0 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9A334 Safari/7534.48.3",
};
static int g_useragent_index = -1;
typedef struct http_simple_local_data {
int has_sent_header;
int has_recv_header;
char *encode_buffer;
}http_simple_local_data;
void http_simple_local_data_init(http_simple_local_data* local) {
local->has_sent_header = 0;
local->has_recv_header = 0;
local->encode_buffer = NULL;
if (g_useragent_index == -1) {
g_useragent_index = xorshift128plus() % (sizeof(g_useragent) / sizeof(*g_useragent));
}
}
obfs * http_simple_new_obfs() {
obfs * self = new_obfs();
self->l_data = malloc(sizeof(http_simple_local_data));
http_simple_local_data_init((http_simple_local_data*)self->l_data);
return self;
}
void http_simple_dispose(obfs *self) {
http_simple_local_data *local = (http_simple_local_data*)self->l_data;
if (local->encode_buffer != NULL) {
free(local->encode_buffer);
local->encode_buffer = NULL;
}
free(local);
dispose_obfs(self);
}
char http_simple_hex(char c) {
if (c < 10) return c + '0';
return c - 10 + 'a';
}
void http_simple_encode_head(http_simple_local_data *local, char *data, int datalength) {
if (local->encode_buffer == NULL) {
local->encode_buffer = (char*)malloc((size_t)(datalength * 3 + 1));
}
int pos = 0;
for (; pos < datalength; ++pos) {
local->encode_buffer[pos * 3] = '%';
local->encode_buffer[pos * 3 + 1] = http_simple_hex(((unsigned char)data[pos] >> 4));
local->encode_buffer[pos * 3 + 2] = http_simple_hex(data[pos] & 0xF);
}
local->encode_buffer[pos * 3] = 0;
}
int http_simple_client_encode(obfs *self, char **pencryptdata, int datalength, size_t* capacity) {
char *encryptdata = *pencryptdata;
http_simple_local_data *local = (http_simple_local_data*)self->l_data;
if (local->has_sent_header) {
return datalength;
}
char hosts[1024];
char * phost[128];
int host_num = 0;
int pos;
char hostport[128];
int head_size = self->server.head_len + (int)(xorshift128plus() & 0x3F);
int outlength;
char * out_buffer = (char*)malloc((size_t)(datalength + 2048));
char * body_buffer = NULL;
if (head_size > datalength)
head_size = datalength;
http_simple_encode_head(local, encryptdata, head_size);
if (self->server.param && strlen(self->server.param) == 0)
self->server.param = NULL;
strncpy(hosts, self->server.param ? self->server.param : self->server.host, sizeof hosts);
phost[host_num++] = hosts;
for (pos = 0; hosts[pos]; ++pos) {
if (hosts[pos] == ',') {
phost[host_num++] = &hosts[pos + 1];
hosts[pos] = 0;
} else if (hosts[pos] == '#') {
char * body_pointer = &hosts[pos + 1];
char * p;
int trans_char = 0;
p = body_buffer = (char*)malloc(2048);
for ( ; *body_pointer; ++body_pointer) {
if (trans_char) {
if (*body_pointer == '\\' ) {
*p = '\\';
} else if (*body_pointer == 'n' ) {
*p = '\r';
*++p = '\n';
} else {
*p = '\\';
*++p = *body_pointer;
}
trans_char = 0;
} else {
if (*body_pointer == '\\') {
trans_char = 1;
continue;
} else if (*body_pointer == '\n') {
*p++ = '\r';
}
*p = *body_pointer;
}
++p;
}
*p = 0;
hosts[pos] = 0;
break;
}
}
host_num = (int)(xorshift128plus() % (uint64_t)host_num);
if (self->server.port == 80)
sprintf(hostport, "%s", phost[host_num]);
else
sprintf(hostport, "%s:%d", phost[host_num], self->server.port);
if (body_buffer) {
sprintf(out_buffer,
"GET /%s HTTP/1.1\r\n"
"Host: %s\r\n"
"%s\r\n\r\n",
local->encode_buffer,
hostport,
body_buffer);
} else {
sprintf(out_buffer,
"GET /%s HTTP/1.1\r\n"
"Host: %s\r\n"
"User-Agent: %s\r\n"
"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
"Accept-Language: en-US,en;q=0.8\r\n"
"Accept-Encoding: gzip, deflate\r\n"
"DNT: 1\r\n"
"Connection: keep-alive\r\n"
"\r\n",
local->encode_buffer,
hostport,
g_useragent[g_useragent_index]
);
}
//LOGI("http header: %s", out_buffer);
outlength = (int)strlen(out_buffer);
memmove(out_buffer + outlength, encryptdata + head_size, datalength - head_size);
outlength += datalength - head_size;
local->has_sent_header = 1;
if ((int)*capacity < outlength) {
*pencryptdata = (char*)realloc(*pencryptdata, *capacity = (size_t)(outlength * 2));
encryptdata = *pencryptdata;
}
memmove(encryptdata, out_buffer, outlength);
free(out_buffer);
if (body_buffer != NULL)
free(body_buffer);
if (local->encode_buffer != NULL) {
free(local->encode_buffer);
local->encode_buffer = NULL;
}
return outlength;
}
int http_simple_client_decode(obfs *self, char **pencryptdata, int datalength, size_t* capacity, int *needsendback) {
char *encryptdata = *pencryptdata;
http_simple_local_data *local = (http_simple_local_data*)self->l_data;
*needsendback = 0;
if (local->has_recv_header) {
return datalength;
}
char* data_begin = strstr(encryptdata, "\r\n\r\n");
if (data_begin) {
int outlength;
data_begin += 4;
local->has_recv_header = 1;
outlength = datalength - (int)(data_begin - encryptdata);
memmove(encryptdata, data_begin, outlength);
return outlength;
} else {
return 0;
}
}
void boundary(char result[])
{
char *str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
int i,lstr;
char ss[3] = {0};
lstr = (int)strlen(str);
srand((unsigned int)time((time_t *)NULL));
for(i = 0; i < 32; ++i)
{
sprintf(ss, "%c", str[(rand()%lstr)]);
strcat(result, ss);
}
}
int http_post_client_encode(obfs *self, char **pencryptdata, int datalength, size_t* capacity) {
char *encryptdata = *pencryptdata;
http_simple_local_data *local = (http_simple_local_data*)self->l_data;
if (local->has_sent_header) {
return datalength;
}
char hosts[1024];
char * phost[128];
int host_num = 0;
int pos;
char hostport[128];
int head_size = self->server.head_len + (int)(xorshift128plus() & 0x3F);
int outlength;
char * out_buffer = (char*)malloc((size_t)(datalength + 4096));
char * body_buffer = NULL;
if (head_size > datalength)
head_size = datalength;
http_simple_encode_head(local, encryptdata, head_size);
if (self->server.param && strlen(self->server.param) == 0)
self->server.param = NULL;
strncpy(hosts, self->server.param ? self->server.param : self->server.host, sizeof hosts);
phost[host_num++] = hosts;
for (pos = 0; hosts[pos]; ++pos) {
if (hosts[pos] == ',') {
phost[host_num++] = &hosts[pos + 1];
hosts[pos] = 0;
} else if (hosts[pos] == '#') {
char * body_pointer = &hosts[pos + 1];
char * p;
int trans_char = 0;
p = body_buffer = (char*)malloc(2048);
for ( ; *body_pointer; ++body_pointer) {
if (trans_char) {
if (*body_pointer == '\\' ) {
*p = '\\';
} else if (*body_pointer == 'n' ) {
*p = '\r';
*++p = '\n';
} else {
*p = '\\';
*++p = *body_pointer;
}
trans_char = 0;
} else {
if (*body_pointer == '\\') {
trans_char = 1;
continue;
} else if (*body_pointer == '\n') {
*p++ = '\r';
}
*p = *body_pointer;
}
++p;
}
*p = 0;
hosts[pos] = 0;
break;
}
}
host_num = (int)(xorshift128plus() % (uint64_t)host_num);
if (self->server.port == 80)
snprintf(hostport, sizeof(hostport), "%s", phost[host_num]);
else
snprintf(hostport, sizeof(hostport), "%s:%d", phost[host_num], self->server.port);
if (body_buffer) {
snprintf(out_buffer, 2048,
"POST /%s HTTP/1.1\r\n"
"Host: %s\r\n"
"%s\r\n\r\n",
local->encode_buffer,
hostport,
body_buffer);
} else {
char result[33] = {0};
boundary(result);
snprintf(out_buffer, 2048,
"POST /%s HTTP/1.1\r\n"
"Host: %s\r\n"
"User-Agent: %s\r\n"
"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
"Accept-Language: en-US,en;q=0.8\r\n"
"Accept-Encoding: gzip, deflate\r\n"
"Content-Type: multipart/form-data; boundary=%s\r\n"
"DNT: 1\r\n"
"Connection: keep-alive\r\n"
"\r\n",
local->encode_buffer,
hostport,
g_useragent[g_useragent_index],
result
);
}
//LOGI("http header: %s", out_buffer);
outlength = (int)strlen(out_buffer);
memmove(out_buffer + outlength, encryptdata + head_size, datalength - head_size);
outlength += datalength - head_size;
local->has_sent_header = 1;
if ((int)*capacity < outlength) {
*pencryptdata = (char*)realloc(*pencryptdata, *capacity = (size_t)(outlength * 2));
encryptdata = *pencryptdata;
}
memmove(encryptdata, out_buffer, outlength);
free(out_buffer);
if (body_buffer != NULL)
free(body_buffer);
if (local->encode_buffer != NULL) {
free(local->encode_buffer);
local->encode_buffer = NULL;
}
return outlength;
}
|
281677160/openwrt-package | 39,678 | luci-app-ssr-plus/shadowsocksr-libev/src/src/obfs/auth_chain.c | #include <string.h>
#include <time.h>
#include <stdlib.h>
#include <limits.h>
#include "auth.h"
#include "obfsutil.h"
#include "crc32.h"
#include "base64.h"
#include "encrypt.h"
#include "obfs.h"
uint32_t g_endian_test = 1;
typedef struct shift128plus_ctx {
uint64_t v[2];
} shift128plus_ctx;
uint64_t shift128plus_next(shift128plus_ctx *ctx) {
uint64_t x = ctx->v[0];
uint64_t y = ctx->v[1];
ctx->v[0] = y;
x ^= x << 23;
x ^= (y ^ (x >> 17) ^ (y >> 26));
ctx->v[1] = x;
return x + y;
}
void i64_memcpy(uint8_t *target, uint8_t *source) {
for (int i = 0; i < 8; ++i)
target[i] = source[7 - i];
}
int find_pos(int arr[], int length, int key) {
int low = 0;
int high = length - 1;
int middle = -1;
if (key > arr[high])
return length;
while (low < high) {
middle = (low + high) / 2;
if (key > arr[middle]) {
low = middle + 1;
} else if (key <= arr[middle]) {
high = middle;
}
}
return low;
}
int data_size_list_compare(const void *a, const void *b) {
return (*(int *) a - *(int *) b);
}
void shift128plus_init_from_bin(shift128plus_ctx *ctx, uint8_t *bin, int bin_size) {
uint8_t fill_bin[16] = {0};
memcpy(fill_bin, bin, bin_size);
if (*(uint8_t *) &g_endian_test == 1) {
memcpy(ctx, fill_bin, 16);
} else {
i64_memcpy((uint8_t *) ctx, fill_bin);
i64_memcpy((uint8_t *) ctx + 8, fill_bin + 8);
}
}
void shift128plus_init_from_bin_datalen(shift128plus_ctx *ctx, uint8_t *bin, int bin_size, int datalen) {
uint8_t fill_bin[16] = {0};
memcpy(fill_bin, bin, bin_size);
fill_bin[0] = datalen;
fill_bin[1] = datalen >> 8;
if (*(uint8_t *) &g_endian_test == 1) {
memcpy(ctx, fill_bin, 16);
} else {
i64_memcpy((uint8_t *) ctx, fill_bin);
i64_memcpy((uint8_t *) ctx + 8, fill_bin + 8);
}
for (int i = 0; i < 4; ++i) {
shift128plus_next(ctx);
}
}
typedef struct auth_chain_global_data {
uint8_t local_client_id[4];
uint32_t connection_id;
} auth_chain_global_data;
typedef struct auth_chain_b_data {
int *data_size_list;
int data_size_list_length;
int *data_size_list2;
int data_size_list2_length;
} auth_chain_b_data;
typedef struct auth_chain_c_data {
int *data_size_list0;
int data_size_list0_length;
} auth_chain_c_data;
typedef struct auth_chain_local_data {
int has_sent_header;
char *recv_buffer;
int recv_buffer_size;
uint32_t recv_id;
uint32_t pack_id;
char *salt;
uint8_t *user_key;
char uid[4];
int user_key_len;
int last_data_len;
uint8_t last_client_hash[16];
uint8_t last_server_hash[16];
shift128plus_ctx random_client;
shift128plus_ctx random_server;
int cipher_init_flag;
cipher_env_t cipher;
enc_ctx_t *cipher_client_ctx;
enc_ctx_t *cipher_server_ctx;
unsigned int (*get_tcp_rand_len)(
struct auth_chain_local_data *local,
server_info *server,
int datalength,
shift128plus_ctx *random,
uint8_t *last_hash
);
void *auth_chain_special_data;
} auth_chain_local_data;
void auth_chain_local_data_init(auth_chain_local_data *local) {
local->has_sent_header = 0;
local->recv_buffer = (char *) malloc(16384);
local->recv_buffer_size = 0;
local->recv_id = 1;
local->pack_id = 1;
local->salt = "";
local->user_key = 0;
local->user_key_len = 0;
local->cipher_init_flag = 0;
local->cipher_client_ctx = 0;
local->cipher_server_ctx = 0;
local->get_tcp_rand_len = NULL;
}
unsigned int auth_chain_a_get_rand_len(
auth_chain_local_data *local,
server_info *server,
int datalength,
shift128plus_ctx *random,
uint8_t *last_hash
) {
if (datalength > 1440)
return 0;
shift128plus_init_from_bin_datalen(random, last_hash, 16, datalength);
if (datalength > 1300)
return (unsigned int) (shift128plus_next(random) % 31);
if (datalength > 900)
return (unsigned int) (shift128plus_next(random) % 127);
if (datalength > 400)
return (unsigned int) (shift128plus_next(random) % 521);
return (unsigned int) (shift128plus_next(random) % 1021);
}
unsigned int auth_chain_b_get_rand_len(
auth_chain_local_data *local,
server_info *server,
int datalength,
shift128plus_ctx *random,
uint8_t *last_hash
) {
if (datalength > 1440)
return 0;
uint16_t overhead = server->overhead;
auth_chain_b_data *special_data = (auth_chain_b_data *) local->auth_chain_special_data;
int other_data_size = datalength + overhead;
// auth_chain_b_get_rand_len
shift128plus_init_from_bin_datalen(random, last_hash, 16, datalength);
int pos = find_pos(special_data->data_size_list, special_data->data_size_list_length, other_data_size);
uint64_t final_pos = pos + shift128plus_next(random) % special_data->data_size_list_length;
if (final_pos < special_data->data_size_list_length) {
return special_data->data_size_list[final_pos] - other_data_size;
}
int pos2 = find_pos(special_data->data_size_list2, special_data->data_size_list2_length, other_data_size);
uint64_t final_pos2 = pos2 + shift128plus_next(random) % special_data->data_size_list2_length;
if (final_pos2 < special_data->data_size_list2_length) {
return special_data->data_size_list2[final_pos2] - other_data_size;
}
if (final_pos2 < pos2 + special_data->data_size_list2_length - 1) {
return 0;
}
if (datalength > 1300)
return (unsigned int) (shift128plus_next(random) % 31);
if (datalength > 900)
return (unsigned int) (shift128plus_next(random) % 127);
if (datalength > 400)
return (unsigned int) (shift128plus_next(random) % 521);
return (unsigned int) (shift128plus_next(random) % 1021);
}
unsigned int auth_chain_c_get_rand_len(
auth_chain_local_data *local,
server_info *server,
int datalength,
shift128plus_ctx *random,
uint8_t *last_hash
) {
uint16_t overhead = server->overhead;
auth_chain_c_data *special_data = (auth_chain_c_data *) local->auth_chain_special_data;
int other_data_size = datalength + overhead;
// must init random in here to make sure output sync in server and client
shift128plus_init_from_bin_datalen(random, last_hash, 16, datalength);
if (other_data_size >= special_data->data_size_list0[special_data->data_size_list0_length - 1]) {
if (datalength > 1440)
return 0;
if (datalength > 1300)
return (unsigned int) (shift128plus_next(random) % 31);
if (datalength > 900)
return (unsigned int) (shift128plus_next(random) % 127);
if (datalength > 400)
return (unsigned int) (shift128plus_next(random) % 521);
return (unsigned int) (shift128plus_next(random) % 1021);
}
int pos = find_pos(special_data->data_size_list0, special_data->data_size_list0_length, other_data_size);
// random select a size in the leftover data_size_list0
uint64_t final_pos = pos + shift128plus_next(random) % (special_data->data_size_list0_length - pos);
return special_data->data_size_list0[final_pos] - other_data_size;
}
unsigned int auth_chain_d_get_rand_len(
auth_chain_local_data *local,
server_info *server,
int datalength,
shift128plus_ctx *random,
uint8_t *last_hash
) {
uint16_t overhead = server->overhead;
auth_chain_c_data *special_data = (auth_chain_c_data *) local->auth_chain_special_data;
int other_data_size = datalength + overhead;
// if other_data_size > the bigest item in data_size_list0, not padding any data
if (other_data_size >= special_data->data_size_list0[special_data->data_size_list0_length - 1]) {
return 0;
}
shift128plus_init_from_bin_datalen(random, last_hash, 16, datalength);
int pos = find_pos(special_data->data_size_list0, special_data->data_size_list0_length, other_data_size);
// random select a size in the leftover data_size_list0
uint64_t final_pos = pos + shift128plus_next(random) % (special_data->data_size_list0_length - pos);
return special_data->data_size_list0[final_pos] - other_data_size;
}
unsigned int auth_chain_e_get_rand_len(
auth_chain_local_data *local,
server_info *server,
int datalength,
shift128plus_ctx *random,
uint8_t *last_hash
) {
shift128plus_init_from_bin_datalen(random, last_hash, 16, datalength);
uint16_t overhead = server->overhead;
auth_chain_c_data *special_data = (auth_chain_c_data *) local->auth_chain_special_data;
int other_data_size = datalength + overhead;
// if other_data_size > the bigest item in data_size_list0, not padding any data
if (other_data_size >= special_data->data_size_list0[special_data->data_size_list0_length - 1]) {
return 0;
}
// use the mini size in the data_size_list0
int pos = find_pos(special_data->data_size_list0, special_data->data_size_list0_length, other_data_size);
return special_data->data_size_list0[pos] - other_data_size;
}
unsigned int auth_chain_f_get_rand_len(
auth_chain_local_data *local,
server_info *server,
int datalength,
shift128plus_ctx *random,
uint8_t *last_hash
) {
return auth_chain_e_get_rand_len(
local,
server,
datalength,
random,
last_hash
);
}
void auth_chain_b_init_data_size(obfs *self, server_info *server) {
auth_chain_b_data *special_data = (auth_chain_b_data *)
((auth_chain_local_data *) self->l_data)->auth_chain_special_data;
shift128plus_ctx *random = (shift128plus_ctx *) malloc(sizeof(shift128plus_ctx));
shift128plus_init_from_bin(random, server->key, 16);
special_data->data_size_list_length = shift128plus_next(random) % 8 + 4;
special_data->data_size_list = (int *) malloc(special_data->data_size_list_length * sizeof(int));
for (int i = 0; i < special_data->data_size_list_length; i++) {
special_data->data_size_list[i] = shift128plus_next(random) % 2340 % 2040 % 1440;
}
// stdlib qsort
qsort(special_data->data_size_list,
special_data->data_size_list_length,
sizeof(int),
data_size_list_compare
);
special_data->data_size_list2_length = shift128plus_next(random) % 16 + 8;
special_data->data_size_list2 = (int *) malloc(special_data->data_size_list2_length * sizeof(int));
for (int i = 0; i < special_data->data_size_list2_length; i++) {
special_data->data_size_list2[i] = shift128plus_next(random) % 2340 % 2040 % 1440;
}
// stdlib qsort
qsort(special_data->data_size_list2,
special_data->data_size_list2_length,
sizeof(int),
data_size_list_compare
);
free(random);
}
void auth_chain_c_init_data_size(obfs *self, server_info *server) {
auth_chain_c_data *special_data = (auth_chain_c_data *)
((auth_chain_local_data *) self->l_data)->auth_chain_special_data;
shift128plus_ctx *random = (shift128plus_ctx *) malloc(sizeof(shift128plus_ctx));
shift128plus_init_from_bin(random, server->key, 16);
special_data->data_size_list0_length = shift128plus_next(random) % (8 + 16) + (4 + 8);
special_data->data_size_list0 = (int *) malloc(special_data->data_size_list0_length * sizeof(int));
for (int i = 0; i < special_data->data_size_list0_length; i++) {
special_data->data_size_list0[i] = shift128plus_next(random) % 2340 % 2040 % 1440;
}
// stdlib qsort
qsort(special_data->data_size_list0,
special_data->data_size_list0_length,
sizeof(int),
data_size_list_compare
);
free(random);
}
#define AUTH_CHAIN_D_MAX_DATA_SIZE_LIST_LIMIT_SIZE 64
void auth_chain_d_check_and_patch_data_size(obfs *self, shift128plus_ctx *random) {
auth_chain_c_data *special_data = (auth_chain_c_data *)
((auth_chain_local_data *) self->l_data)->auth_chain_special_data;
while (special_data->data_size_list0[special_data->data_size_list0_length - 1] < 1300
&& special_data->data_size_list0_length < AUTH_CHAIN_D_MAX_DATA_SIZE_LIST_LIMIT_SIZE) {
// data_size_list0.size + 1
special_data->data_size_list0[special_data->data_size_list0_length] =
shift128plus_next(random) % 2340 % 2040 % 1440;
++(special_data->data_size_list0_length);
}
}
void auth_chain_d_init_data_size(obfs *self, server_info *server) {
auth_chain_c_data *special_data = (auth_chain_c_data *)
((auth_chain_local_data *) self->l_data)->auth_chain_special_data;
shift128plus_ctx *random = (shift128plus_ctx *) malloc(sizeof(shift128plus_ctx));
shift128plus_init_from_bin(random, server->key, 16);
special_data->data_size_list0_length = shift128plus_next(random) % (8 + 16) + (4 + 8);
special_data->data_size_list0 = (int *) malloc(AUTH_CHAIN_D_MAX_DATA_SIZE_LIST_LIMIT_SIZE * sizeof(int));
for (int i = 0; i < special_data->data_size_list0_length; i++) {
special_data->data_size_list0[i] = shift128plus_next(random) % 2340 % 2040 % 1440;
}
// stdlib qsort
qsort(special_data->data_size_list0,
special_data->data_size_list0_length,
sizeof(int),
data_size_list_compare
);
int old_len = special_data->data_size_list0_length;
auth_chain_d_check_and_patch_data_size(self, random);
if (old_len != special_data->data_size_list0_length) {
// if check_and_patch_data_size are work, re-sort again.
// stdlib qsort
qsort(special_data->data_size_list0,
special_data->data_size_list0_length,
sizeof(int),
data_size_list_compare
);
}
free(random);
}
void auth_chain_f_init_data_size(obfs *self, server_info *server, const uint8_t *key_change_datetime_key_bytes) {
auth_chain_c_data *special_data = (auth_chain_c_data *)
((auth_chain_local_data *) self->l_data)->auth_chain_special_data;
shift128plus_ctx *random = (shift128plus_ctx *) malloc(sizeof(shift128plus_ctx));
uint8_t *newKey = (uint8_t *) malloc(sizeof(uint8_t) * server->key_len);
memcpy(newKey, server->key, server->key_len);
for (int i = 0; i != 8; ++i) {
newKey[i] ^= key_change_datetime_key_bytes[i];
}
shift128plus_init_from_bin(random, newKey, 16);
free(newKey);
newKey = NULL;
special_data->data_size_list0_length = shift128plus_next(random) % (8 + 16) + (4 + 8);
special_data->data_size_list0 = (int *) malloc(AUTH_CHAIN_D_MAX_DATA_SIZE_LIST_LIMIT_SIZE * sizeof(int));
for (int i = 0; i < special_data->data_size_list0_length; i++) {
special_data->data_size_list0[i] = shift128plus_next(random) % 2340 % 2040 % 1440;
}
// stdlib qsort
qsort(special_data->data_size_list0,
special_data->data_size_list0_length,
sizeof(int),
data_size_list_compare
);
int old_len = special_data->data_size_list0_length;
auth_chain_d_check_and_patch_data_size(self, random);
if (old_len != special_data->data_size_list0_length) {
// if check_and_patch_data_size are work, re-sort again.
// stdlib qsort
qsort(special_data->data_size_list0,
special_data->data_size_list0_length,
sizeof(int),
data_size_list_compare
);
}
free(random);
}
void *auth_chain_a_init_data() {
auth_chain_global_data *global = (auth_chain_global_data *) malloc(sizeof(auth_chain_global_data));
rand_bytes(global->local_client_id, 4);
rand_bytes((uint8_t *) &global->connection_id, 4);
global->connection_id &= 0xFFFFFF;
return global;
}
void *auth_chain_b_init_data() {
return auth_chain_a_init_data();
}
void *auth_chain_c_init_data() {
return auth_chain_a_init_data();
}
void *auth_chain_d_init_data() {
return auth_chain_c_init_data();
}
void *auth_chain_e_init_data() {
return auth_chain_d_init_data();
}
void *auth_chain_f_init_data() {
return auth_chain_e_init_data();
}
obfs *auth_chain_a_new_obfs() {
obfs *self = new_obfs();
self->l_data = malloc(sizeof(auth_chain_local_data));
auth_chain_local_data_init((auth_chain_local_data *) self->l_data);
((auth_chain_local_data *) self->l_data)->salt = "auth_chain_a";
((auth_chain_local_data *) self->l_data)->get_tcp_rand_len = auth_chain_a_get_rand_len;
return self;
}
obfs *auth_chain_b_new_obfs() {
obfs *self = new_obfs();
self->l_data = malloc(sizeof(auth_chain_local_data));
auth_chain_local_data_init((auth_chain_local_data *) self->l_data);
((auth_chain_local_data *) self->l_data)->salt = "auth_chain_b";
((auth_chain_local_data *) self->l_data)->get_tcp_rand_len = auth_chain_b_get_rand_len;
auth_chain_b_data *special_data = (auth_chain_b_data *) malloc(sizeof(auth_chain_b_data));
special_data->data_size_list = NULL;
special_data->data_size_list_length = 0;
special_data->data_size_list2 = NULL;
special_data->data_size_list2_length = 0;
((auth_chain_local_data *) self->l_data)->auth_chain_special_data = special_data;
return self;
}
obfs *auth_chain_c_new_obfs() {
obfs *self = new_obfs();
self->l_data = malloc(sizeof(auth_chain_local_data));
auth_chain_local_data_init((auth_chain_local_data *) self->l_data);
((auth_chain_local_data *) self->l_data)->salt = "auth_chain_c";
((auth_chain_local_data *) self->l_data)->get_tcp_rand_len = auth_chain_c_get_rand_len;
auth_chain_c_data *special_data = (auth_chain_c_data *) malloc(sizeof(auth_chain_c_data));
special_data->data_size_list0 = NULL;
special_data->data_size_list0_length = 0;
((auth_chain_local_data *) self->l_data)->auth_chain_special_data = special_data;
return self;
}
obfs *auth_chain_d_new_obfs() {
obfs *self = auth_chain_c_new_obfs();
((auth_chain_local_data *) self->l_data)->salt = "auth_chain_d";
((auth_chain_local_data *) self->l_data)->get_tcp_rand_len = auth_chain_d_get_rand_len;
return self;
}
obfs *auth_chain_e_new_obfs() {
obfs *self = auth_chain_d_new_obfs();
((auth_chain_local_data *) self->l_data)->salt = "auth_chain_e";
((auth_chain_local_data *) self->l_data)->get_tcp_rand_len = auth_chain_e_get_rand_len;
return self;
}
obfs *auth_chain_f_new_obfs() {
obfs *self = auth_chain_e_new_obfs();
((auth_chain_local_data *) self->l_data)->salt = "auth_chain_f";
((auth_chain_local_data *) self->l_data)->get_tcp_rand_len = auth_chain_f_get_rand_len;
return self;
}
int auth_chain_a_get_overhead(obfs *self) {
return 4;
}
int auth_chain_b_get_overhead(obfs *self) {
return auth_chain_a_get_overhead(self);
}
int auth_chain_c_get_overhead(obfs *self) {
return auth_chain_a_get_overhead(self);
}
int auth_chain_d_get_overhead(obfs *self) {
return auth_chain_c_get_overhead(self);
}
int auth_chain_e_get_overhead(obfs *self) {
return auth_chain_d_get_overhead(self);
}
int auth_chain_f_get_overhead(obfs *self) {
return auth_chain_e_get_overhead(self);
}
void auth_chain_a_dispose(obfs *self) {
auth_chain_local_data *local = (auth_chain_local_data *) self->l_data;
if (local->recv_buffer != NULL) {
free(local->recv_buffer);
local->recv_buffer = NULL;
}
if (local->user_key != NULL) {
free(local->user_key);
local->user_key = NULL;
}
if (local->cipher_init_flag) {
if (local->cipher_client_ctx) {
enc_ctx_release(&local->cipher, local->cipher_client_ctx);
}
if (local->cipher_server_ctx) {
enc_ctx_release(&local->cipher, local->cipher_server_ctx);
}
enc_release(&local->cipher);
local->cipher_init_flag = 0;
}
free(local);
self->l_data = NULL;
dispose_obfs(self);
}
void auth_chain_b_dispose(obfs *self) {
auth_chain_local_data *local = (auth_chain_local_data *) self->l_data;
auth_chain_b_data *special_data = (auth_chain_b_data *) local->auth_chain_special_data;
if (local->auth_chain_special_data != NULL) {
if (special_data->data_size_list != NULL) {
free(special_data->data_size_list);
special_data->data_size_list = NULL;
special_data->data_size_list_length = 0;
}
if (special_data->data_size_list2 != NULL) {
free(special_data->data_size_list2);
special_data->data_size_list2 = NULL;
special_data->data_size_list2_length = 0;
}
free(local->auth_chain_special_data);
local->auth_chain_special_data = NULL;
}
auth_chain_a_dispose(self);
}
void auth_chain_c_dispose(obfs *self) {
auth_chain_local_data *local = (auth_chain_local_data *) self->l_data;
auth_chain_c_data *special_data = (auth_chain_c_data *) local->auth_chain_special_data;
if (local->auth_chain_special_data != NULL) {
if (special_data->data_size_list0 != NULL) {
free(special_data->data_size_list0);
special_data->data_size_list0 = NULL;
special_data->data_size_list0_length = 0;
}
free(local->auth_chain_special_data);
local->auth_chain_special_data = NULL;
}
auth_chain_a_dispose(self);
}
void auth_chain_d_dispose(obfs *self) {
auth_chain_c_dispose(self);
}
void auth_chain_e_dispose(obfs *self) {
auth_chain_d_dispose(self);
}
void auth_chain_f_dispose(obfs *self) {
auth_chain_e_dispose(self);
}
void auth_chain_a_set_server_info(obfs *self, server_info *server) {
// dont change server.overhead in there
// the server.overhead are counted from the local.c
// the input's server.overhead is the total server.overhead that sum of all the plugin's overhead
memmove(&self->server, server, sizeof(server_info));
}
void auth_chain_b_set_server_info(obfs *self, server_info *server) {
memmove(&self->server, server, sizeof(server_info));
// auth_chain_b_init_data_size() init in there
auth_chain_b_init_data_size(self, &self->server);
}
void auth_chain_c_set_server_info(obfs *self, server_info *server) {
memmove(&self->server, server, sizeof(server_info));
// auth_chain_c_init_data_size() init in there
auth_chain_c_init_data_size(self, &self->server);
}
void auth_chain_d_set_server_info(obfs *self, server_info *server) {
memmove(&self->server, server, sizeof(server_info));
// auth_chain_d_init_data_size() init in there
auth_chain_d_init_data_size(self, &self->server);
}
void auth_chain_e_set_server_info(obfs *self, server_info *server) {
auth_chain_d_set_server_info(self, server);
}
void auth_chain_f_set_server_info(obfs *self, server_info *server) {
memmove(&self->server, server, sizeof(server_info));
uint64_t key_change_interval = 60 * 60 * 24; // a day by second
if (server->param != NULL && server->param[0] != 0) {
char *delim1 = strchr(server->param, '#');
if (delim1 != NULL && delim1[1] != '\0') {
++delim1;
char *delim2 = strchr(delim1, '#');
if (delim2 == NULL) {
delim2 = strchr(delim1, '\0');
}
unsigned long l = delim2 - delim1;
if (l > 2) {
long long n = strtoll(delim1, &delim2, 0);
if (n != 0 && n != LLONG_MAX && n != LLONG_MIN && n > 0) {
key_change_interval = (uint64_t) n;
}
}
}
}
uint8_t *key_change_datetime_key_bytes = (uint8_t *) malloc(sizeof(uint8_t) * 8);
uint64_t key_change_datetime_key = (uint64_t) (time(NULL)) / key_change_interval;
for (int i = 7; i >= 0; --i) {
key_change_datetime_key_bytes[7 - i] = (uint8_t) ((key_change_datetime_key >> (8 * i)) & 0xFF);
}
auth_chain_f_init_data_size(self, &self->server, key_change_datetime_key_bytes);
free(key_change_datetime_key_bytes);
key_change_datetime_key_bytes = NULL;
}
unsigned int udp_get_rand_len(shift128plus_ctx *random, uint8_t *last_hash) {
shift128plus_init_from_bin(random, last_hash, 16);
return shift128plus_next(random) % 127;
}
unsigned int get_rand_start_pos(int rand_len, shift128plus_ctx *random) {
if (rand_len > 0)
return shift128plus_next(random) % 8589934609 % rand_len;
return 0;
}
unsigned int get_client_rand_len(auth_chain_local_data *local, server_info *server, int datalength) {
return local->get_tcp_rand_len(local, server, datalength, &local->random_client, local->last_client_hash);
}
unsigned int get_server_rand_len(auth_chain_local_data *local, server_info *server, int datalength) {
return local->get_tcp_rand_len(local, server, datalength, &local->random_server, local->last_server_hash);
}
int auth_chain_a_pack_data(char *data, int datalength, char *outdata, auth_chain_local_data *local,
server_info *server) {
unsigned int rand_len = get_client_rand_len(local, server, datalength);
int out_size = (int) rand_len + datalength + 2;
outdata[0] = (char) ((uint8_t) datalength ^ local->last_client_hash[14]);
outdata[1] = (char) ((uint8_t) (datalength >> 8) ^ local->last_client_hash[15]);
{
uint8_t *rnd_data = (uint8_t *)malloc(rand_len);
rand_bytes(rnd_data, (int) rand_len);
if (datalength > 0) {
int start_pos = get_rand_start_pos(rand_len, &local->random_client);
size_t out_len;
ss_encrypt_buffer(&local->cipher, local->cipher_client_ctx,
data, datalength, &outdata[2 + start_pos], &out_len);
memcpy(outdata + 2, rnd_data, start_pos);
memcpy(outdata + 2 + start_pos + datalength, rnd_data + start_pos, rand_len - start_pos);
} else {
memcpy(outdata + 2, rnd_data, rand_len);
}
free(rnd_data);
}
uint8_t key_len = (uint8_t) (local->user_key_len + 4);
uint8_t *key = (uint8_t *)malloc(key_len);
memcpy(key, local->user_key, local->user_key_len);
memintcopy_lt(key + key_len - 4, local->pack_id);
++local->pack_id;
ss_md5_hmac_with_key((char *) local->last_client_hash, outdata, out_size, key, key_len);
memcpy(outdata + out_size, local->last_client_hash, 2);
free(key);
return out_size + 2;
}
int auth_chain_a_pack_auth_data(auth_chain_global_data *global, server_info *server, auth_chain_local_data *local,
char *data, int datalength, char *outdata) {
const int authhead_len = 4 + 8 + 4 + 16 + 4;
const char *salt = local->salt;
int out_size = authhead_len;
++global->connection_id;
if (global->connection_id > 0xFF000000) {
rand_bytes(global->local_client_id, 8);
rand_bytes((uint8_t *) &global->connection_id, 4);
global->connection_id &= 0xFFFFFF;
}
char encrypt[20];
uint8_t *key = (uint8_t *)malloc(server->iv_len + server->key_len);
uint8_t key_len = (uint8_t) (server->iv_len + server->key_len);
memcpy(key, server->iv, server->iv_len);
memcpy(key + server->iv_len, server->key, server->key_len);
time_t t = time(NULL);
memintcopy_lt(encrypt, (uint32_t) t);
memcpy(encrypt + 4, global->local_client_id, 4);
memintcopy_lt(encrypt + 8, global->connection_id);
encrypt[12] = (char) server->overhead;
encrypt[13] = (char) (server->overhead >> 8);
encrypt[14] = 0;
encrypt[15] = 0;
// first 12 bytes
{
rand_bytes((uint8_t *) outdata, 4);
ss_md5_hmac_with_key((char *) local->last_client_hash, (char *) outdata, 4, key, key_len);
memcpy(outdata + 4, local->last_client_hash, 8);
}
free(key);
// uid & 16 bytes auth data
{
uint8_t uid[4];
if (local->user_key == NULL) {
if (server->param != NULL && server->param[0] != 0) {
char *param = server->param;
char *delim = strchr(param, ':');
if (delim != NULL) {
char uid_str[16] = "";
strncpy(uid_str, param, delim - param);
char key_str[128];
strcpy(key_str, delim + 1);
long uid_long = strtol(uid_str, NULL, 10);
memintcopy_lt((char *) local->uid, (uint32_t) uid_long);
local->user_key_len = (int) strlen(key_str);
local->user_key = (uint8_t *) malloc((size_t) local->user_key_len);
memcpy(local->user_key, key_str, local->user_key_len);
}
}
if (local->user_key == NULL) {
rand_bytes((uint8_t *) local->uid, 4);
local->user_key_len = (int) server->key_len;
local->user_key = (uint8_t *) malloc((size_t) local->user_key_len);
memcpy(local->user_key, server->key, local->user_key_len);
}
}
for (int i = 0; i < 4; ++i) {
uid[i] = local->uid[i] ^ local->last_client_hash[8 + i];
}
char encrypt_key_base64[256] = {0};
unsigned char *encrypt_key = (unsigned char *)malloc(local->user_key_len);
memcpy(encrypt_key, local->user_key, local->user_key_len);
base64_encode(encrypt_key, (unsigned int) local->user_key_len, encrypt_key_base64);
free(encrypt_key);
int salt_len = (int)strlen(salt);
int base64_len = (local->user_key_len + 2) / 3 * 4;
memcpy(encrypt_key_base64 + base64_len, salt, salt_len);
char enc_key[16];
int enc_key_len = base64_len + salt_len;
bytes_to_key_with_size(encrypt_key_base64, (size_t) enc_key_len, (uint8_t *) enc_key, 16);
char encrypt_data[16];
ss_aes_128_cbc(encrypt, encrypt_data, enc_key);
memcpy(encrypt, uid, 4);
memcpy(encrypt + 4, encrypt_data, 16);
}
// final HMAC
{
ss_md5_hmac_with_key((char *) local->last_server_hash, encrypt, 20, local->user_key, local->user_key_len);
memcpy(outdata + 12, encrypt, 20);
memcpy(outdata + 12 + 20, local->last_server_hash, 4);
}
char password[256] = {0};
base64_encode(local->user_key, local->user_key_len, password);
base64_encode(local->last_client_hash, 16, password + strlen(password));
local->cipher_init_flag = 1;
enc_init(&local->cipher, password, "rc4");
local->cipher_client_ctx = malloc(sizeof(enc_ctx_t));
local->cipher_server_ctx = malloc(sizeof(enc_ctx_t));
enc_ctx_init(&local->cipher, local->cipher_client_ctx, 1);
enc_ctx_init(&local->cipher, local->cipher_server_ctx, 0);
out_size += auth_chain_a_pack_data(data, datalength, outdata + out_size, local, server);
return out_size;
}
int auth_chain_a_client_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t *capacity) {
char *plaindata = *pplaindata;
server_info *server = (server_info *) &self->server;
auth_chain_local_data *local = (auth_chain_local_data *) self->l_data;
char *out_buffer = (char *) malloc((size_t) (datalength * 2 + 4096));
char *buffer = out_buffer;
char *data = plaindata;
int len = datalength;
int pack_len;
if (len > 0 && local->has_sent_header == 0) {
int head_size = 1200;
if (head_size > datalength)
head_size = datalength;
pack_len = auth_chain_a_pack_auth_data((auth_chain_global_data *) self->server.g_data, &self->server, local,
data, head_size, buffer);
buffer += pack_len;
data += head_size;
len -= head_size;
local->has_sent_header = 1;
}
int unit_size = server->tcp_mss - server->overhead;
while (len > unit_size) {
pack_len = auth_chain_a_pack_data(data, unit_size, buffer, local, &self->server);
buffer += pack_len;
data += unit_size;
len -= unit_size;
}
if (len > 0) {
pack_len = auth_chain_a_pack_data(data, len, buffer, local, &self->server);
buffer += pack_len;
}
len = (int) (buffer - out_buffer);
if ((int) *capacity < len) {
*pplaindata = (char *) realloc(*pplaindata, *capacity = (size_t) (len * 2));
// TODO check realloc failed
plaindata = *pplaindata;
}
local->last_data_len = datalength;
memmove(plaindata, out_buffer, len);
free(out_buffer);
return len;
}
int auth_chain_a_client_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t *capacity) {
char *plaindata = *pplaindata;
auth_chain_local_data *local = (auth_chain_local_data *) self->l_data;
server_info *server = (server_info *) &self->server;
uint8_t *recv_buffer = (uint8_t *) local->recv_buffer;
if (local->recv_buffer_size + datalength > 16384)
return -1;
memmove(recv_buffer + local->recv_buffer_size, plaindata, datalength);
local->recv_buffer_size += datalength;
int key_len = local->user_key_len + 4;
uint8_t *key = (uint8_t *) malloc((size_t) key_len);
memcpy(key, local->user_key, local->user_key_len);
char *out_buffer = (char *) malloc((size_t) local->recv_buffer_size);
char *buffer = out_buffer;
char error = 0;
while (local->recv_buffer_size > 4) {
memintcopy_lt(key + key_len - 4, local->recv_id);
int data_len = (int) (((unsigned) (recv_buffer[1] ^ local->last_server_hash[15]) << 8) +
(recv_buffer[0] ^ local->last_server_hash[14]));
int rand_len = get_server_rand_len(local, server, data_len);
int len = rand_len + data_len;
if (len >= 4096) {
local->recv_buffer_size = 0;
error = 1;
break;
}
if ((len += 4) > local->recv_buffer_size)
break;
char hash[16];
ss_md5_hmac_with_key(hash, (char *) recv_buffer, len - 2, key, key_len);
if (memcmp(hash, recv_buffer + len - 2, 2)) {
local->recv_buffer_size = 0;
error = 1;
break;
}
int pos;
if (data_len > 0 && rand_len > 0) {
pos = 2 + get_rand_start_pos(rand_len, &local->random_server);
} else {
pos = 2;
}
size_t out_len;
ss_decrypt_buffer(&local->cipher, local->cipher_server_ctx,
(char *) recv_buffer + pos, data_len, buffer, &out_len);
if (local->recv_id == 1) {
server->tcp_mss = (uint8_t) buffer[0] | ((uint8_t) buffer[1] << 8);
memmove(buffer, buffer + 2, out_len -= 2);
}
memcpy(local->last_server_hash, hash, 16);
++local->recv_id;
buffer += out_len;
memmove(recv_buffer, recv_buffer + len, local->recv_buffer_size -= len);
}
int len;
if (error == 0) {
len = (int) (buffer - out_buffer);
if ((int) *capacity < len) {
*pplaindata = (char *) realloc(*pplaindata, *capacity = (size_t) (len * 2));
plaindata = *pplaindata;
}
memmove(plaindata, out_buffer, len);
} else {
len = -1;
}
free(out_buffer);
free(key);
return len;
}
int auth_chain_a_client_udp_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t *capacity) {
char *plaindata = *pplaindata;
server_info *server = (server_info *) &self->server;
auth_chain_local_data *local = (auth_chain_local_data *) self->l_data;
char *out_buffer = (char *)malloc(datalength + 1024);
if (local->user_key == NULL) {
if (self->server.param != NULL && self->server.param[0] != 0) {
char *param = self->server.param;
char *delim = strchr(param, ':');
if (delim != NULL) {
char uid_str[16] = "";
strncpy(uid_str, param, delim - param);
char key_str[128];
strcpy(key_str, delim + 1);
long uid_long = strtol(uid_str, NULL, 10);
memintcopy_lt(local->uid, (uint32_t) uid_long);
local->user_key_len = (int) strlen(key_str);
local->user_key = (uint8_t *) malloc((size_t) local->user_key_len);
memcpy(local->user_key, key_str, local->user_key_len);
}
}
if (local->user_key == NULL) {
rand_bytes((uint8_t *) local->uid, 4);
local->user_key_len = (int) self->server.key_len;
local->user_key = (uint8_t *) malloc((size_t) local->user_key_len);
memcpy(local->user_key, self->server.key, local->user_key_len);
}
}
char auth_data[3];
uint8_t hash[16];
ss_md5_hmac_with_key((char *) hash, auth_data, 3, server->key, server->key_len);
int rand_len = udp_get_rand_len(&local->random_client, hash);
uint8_t *rnd_data = (uint8_t *)malloc(rand_len);
rand_bytes(rnd_data, (int) rand_len);
int outlength = datalength + rand_len + 8;
char password[256] = {0};
base64_encode(local->user_key, local->user_key_len, password);
base64_encode(hash, 16, password + strlen(password));
{
enc_init(&local->cipher, password, "rc4");
enc_ctx_t ctx;
enc_ctx_init(&local->cipher, &ctx, 1);
size_t out_len;
ss_encrypt_buffer(&local->cipher, &ctx,
plaindata, datalength, out_buffer, &out_len);
enc_ctx_release(&local->cipher, &ctx);
enc_release(&local->cipher);
}
uint8_t uid[4];
for (int i = 0; i < 4; ++i) {
uid[i] = local->uid[i] ^ hash[i];
}
memmove(out_buffer + datalength, rnd_data, rand_len);
memmove(out_buffer + outlength - 8, auth_data, 3);
memmove(out_buffer + outlength - 5, uid, 4);
free(rnd_data);
ss_md5_hmac_with_key((char *) hash, out_buffer, outlength - 1, local->user_key, local->user_key_len);
memmove(out_buffer + outlength - 1, hash, 1);
if ((int) *capacity < outlength) {
*pplaindata = (char *) realloc(*pplaindata, *capacity = (size_t) (outlength * 2));
plaindata = *pplaindata;
}
memmove(plaindata, out_buffer, outlength);
free(out_buffer);
return outlength;
}
int auth_chain_a_client_udp_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t *capacity) {
if (datalength <= 8)
return 0;
char *plaindata = *pplaindata;
server_info *server = (server_info *) &self->server;
auth_chain_local_data *local = (auth_chain_local_data *) self->l_data;
uint8_t hash[16];
ss_md5_hmac_with_key((char *) hash, plaindata, datalength - 1, local->user_key, local->user_key_len);
if (*hash != ((uint8_t *) plaindata)[datalength - 1])
return 0;
ss_md5_hmac_with_key((char *) hash, plaindata + datalength - 8, 7, server->key, server->key_len);
int rand_len = udp_get_rand_len(&local->random_server, hash);
int outlength = datalength - rand_len - 8;
char password[256] = {0};
base64_encode(local->user_key, local->user_key_len, password);
base64_encode(hash, 16, password + strlen(password));
{
enc_init(&local->cipher, password, "rc4");
enc_ctx_t ctx;
enc_ctx_init(&local->cipher, &ctx, 0);
size_t out_len;
ss_decrypt_buffer(&local->cipher, &ctx, plaindata, outlength, plaindata, &out_len);
enc_ctx_release(&local->cipher, &ctx);
enc_release(&local->cipher);
}
return outlength;
}
|
281677160/openwrt-package | 14,551 | luci-app-ssr-plus/shadowsocksr-libev/src/src/obfs/tls1.2_ticket.c | #include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <time.h>
#include "tls1.2_ticket.h"
#include "obfsutil.h"
#include "encrypt.h"
typedef struct tls12_ticket_auth_global_data {
uint8_t local_client_id[32];
} tls12_ticket_auth_global_data;
typedef struct tls12_ticket_auth_local_data {
int handshake_status;
char *send_buffer;
int send_buffer_size;
char *recv_buffer;
int recv_buffer_size;
} tls12_ticket_auth_local_data;
void tls12_ticket_auth_local_data_init(tls12_ticket_auth_local_data *local) {
local->handshake_status = 0;
local->send_buffer = malloc(0);
local->send_buffer_size = 0;
local->recv_buffer = malloc(0);
local->recv_buffer_size = 0;
}
void *tls12_ticket_auth_init_data() {
tls12_ticket_auth_global_data *global =
(tls12_ticket_auth_global_data *) malloc(sizeof(tls12_ticket_auth_global_data));
rand_bytes(global->local_client_id, 32);
return global;
}
obfs *tls12_ticket_auth_new_obfs() {
obfs *self = new_obfs();
self->l_data = malloc(sizeof(tls12_ticket_auth_local_data));
tls12_ticket_auth_local_data_init((tls12_ticket_auth_local_data *) self->l_data);
return self;
}
int tls12_ticket_auth_get_overhead(obfs *self) {
return 5;
}
void tls12_ticket_auth_dispose(obfs *self) {
tls12_ticket_auth_local_data *local = (tls12_ticket_auth_local_data *) self->l_data;
if (local->send_buffer != NULL) {
free(local->send_buffer);
local->send_buffer = NULL;
}
if (local->recv_buffer != NULL) {
free(local->recv_buffer);
local->recv_buffer = NULL;
}
free(local);
dispose_obfs(self);
}
int tls12_ticket_pack_auth_data(tls12_ticket_auth_global_data *global, server_info *server, char *outdata) {
int out_size = 32;
time_t t = time(NULL);
outdata[0] = (char) (t >> 24);
outdata[1] = (char) (t >> 16);
outdata[2] = (char) (t >> 8);
outdata[3] = (char) t;
rand_bytes((uint8_t *) outdata + 4, 18);
uint8_t *key = (uint8_t *) malloc(server->key_len + 32);
char hash[SHA1_BYTES];
memcpy(key, server->key, server->key_len);
memcpy(key + server->key_len, global->local_client_id, 32);
ss_sha1_hmac_with_key(hash, outdata, out_size - OBFS_HMAC_SHA1_LEN, key, (int) (server->key_len + 32));
free(key);
memcpy(outdata + out_size - OBFS_HMAC_SHA1_LEN, hash, OBFS_HMAC_SHA1_LEN);
return out_size;
}
void tls12_ticket_auth_pack_data(char *encryptdata, int start, int len, char *out_buffer, int outlength) {
out_buffer[outlength] = 0x17;
out_buffer[outlength + 1] = 0x3;
out_buffer[outlength + 2] = 0x3;
out_buffer[outlength + 3] = (char) (len >> 8);
out_buffer[outlength + 4] = (char) len;
memcpy(out_buffer + outlength + 5, encryptdata + start, len);
}
int tls12_ticket_auth_client_encode(obfs *self, char **pencryptdata, int datalength, size_t *capacity) {
char *encryptdata = *pencryptdata;
tls12_ticket_auth_local_data *local = (tls12_ticket_auth_local_data *) self->l_data;
tls12_ticket_auth_global_data *global = (tls12_ticket_auth_global_data *) self->server.g_data;
char *out_buffer = NULL;
if (local->handshake_status == 8) {
if (datalength < 1024) {
if ((int) *capacity < datalength + 5) {
*pencryptdata = (char *) realloc(*pencryptdata, *capacity = (size_t) ((datalength + 5) * 2));
encryptdata = *pencryptdata;
}
memmove(encryptdata + 5, encryptdata, datalength);
encryptdata[0] = 0x17;
encryptdata[1] = 0x3;
encryptdata[2] = 0x3;
encryptdata[3] = (char) (datalength >> 8);
encryptdata[4] = (char) datalength;
return datalength + 5;
} else {
out_buffer = (char *) malloc((size_t) (datalength + 4096));
int start = 0;
int outlength = 0;
int len;
while (datalength - start > 2048) {
len = xorshift128plus() % 4096 + 100;
if (len > datalength - start)
len = datalength - start;
tls12_ticket_auth_pack_data(encryptdata, start, len, out_buffer, outlength);
outlength += len + 5;
start += len;
}
if (datalength - start > 0) {
len = datalength - start;
tls12_ticket_auth_pack_data(encryptdata, start, len, out_buffer, outlength);
outlength += len + 5;
}
if ((int) *capacity < outlength) {
*pencryptdata = (char *) realloc(*pencryptdata, *capacity = (size_t) (outlength * 2));
encryptdata = *pencryptdata;
}
memcpy(encryptdata, out_buffer, outlength);
free(out_buffer);
return outlength;
}
}
if (datalength > 0) {
if (datalength < 1024) {
local->send_buffer = (char *) realloc(local->send_buffer,
(size_t) (local->send_buffer_size + datalength + 5));
tls12_ticket_auth_pack_data(encryptdata, 0, datalength, local->send_buffer, local->send_buffer_size);
local->send_buffer_size += datalength + 5;
} else {
out_buffer = (char *) malloc((size_t) (datalength + 4096));
int start = 0;
int outlength = 0;
int len;
while (datalength - start > 2048) {
len = xorshift128plus() % 4096 + 100;
if (len > datalength - start)
len = datalength - start;
tls12_ticket_auth_pack_data(encryptdata, start, len, out_buffer, outlength);
outlength += len + 5;
start += len;
}
if (datalength - start > 0) {
len = datalength - start;
tls12_ticket_auth_pack_data(encryptdata, start, len, out_buffer, outlength);
outlength += len + 5;
}
if ((int) *capacity < outlength) {
*pencryptdata = (char *) realloc(*pencryptdata, *capacity = (size_t) (outlength * 2));
encryptdata = *pencryptdata;
}
local->send_buffer = (char *) realloc(local->send_buffer, (size_t) (local->send_buffer_size + outlength));
memcpy(local->send_buffer + local->send_buffer_size, out_buffer, outlength);
local->send_buffer_size += outlength;
free(out_buffer);
}
}
if (local->handshake_status == 0) {
#define CSTR_DECL(name, len, str) const char* name = str; const int (len) = sizeof(str) - 1;
CSTR_DECL(tls_data0, tls_data0_len,
"\x00\x1c\xc0\x2b\xc0\x2f\xcc\xa9\xcc\xa8\xcc\x14\xcc\x13\xc0\x0a\xc0\x14\xc0\x09\xc0\x13\x00\x9c\x00\x35\x00\x2f\x00\x0a\x01\x00"
);
CSTR_DECL(tls_data1, tls_data1_len,
"\xff\x01\x00\x01\x00"
);
CSTR_DECL(tls_data2, tls_data2_len,
"\x00\x17\x00\x00\x00\x23\x00\xd0"
);
CSTR_DECL(tls_data3, tls_data3_len,
"\x00\x0d\x00\x16\x00\x14\x06\x01\x06\x03\x05\x01\x05\x03\x04\x01\x04\x03\x03\x01\x03\x03\x02\x01\x02\x03\x00\x05\x00\x05\x01\x00\x00\x00\x00\x00\x12\x00\x00\x75\x50\x00\x00\x00\x0b\x00\x02\x01\x00\x00\x0a\x00\x06\x00\x04\x00\x17\x00\x18"
//"00150066000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" // padding
);
uint8_t tls_data[2048];
int tls_data_len = 0;
memcpy(tls_data, tls_data1, tls_data1_len);
tls_data_len += tls_data1_len;
char hosts[1024];
char *phost[128];
int host_num = 0;
int pos;
char sni[256] = {0};
char *param = NULL;
if (self->server.param && strlen(self->server.param) > 0)
param = self->server.param;
else
param = self->server.host;
strncpy(hosts, param, sizeof hosts);
phost[host_num++] = hosts;
for (pos = 0; hosts[pos]; ++pos) {
if (hosts[pos] == ',') {
phost[host_num++] = &hosts[pos + 1];
hosts[pos] = 0;
}
}
host_num = (int) (xorshift128plus() % (uint64_t) host_num);
snprintf(sni, sizeof sni, "%s", phost[host_num]);
int sni_len = (int) strlen(sni);
if (sni_len > 0 && sni[sni_len - 1] >= '0' && sni[sni_len - 1] <= '9')
sni_len = 0;
tls_data[tls_data_len] = '\0';
tls_data[tls_data_len + 1] = '\0';
tls_data[tls_data_len + 2] = (uint8_t) ((sni_len + 5) >> 8);
tls_data[tls_data_len + 3] = (uint8_t) (sni_len + 5);
tls_data[tls_data_len + 4] = (uint8_t) ((sni_len + 3) >> 8);
tls_data[tls_data_len + 5] = (uint8_t) (sni_len + 3);
tls_data[tls_data_len + 6] = '\0';
tls_data[tls_data_len + 7] = (uint8_t) (sni_len >> 8);
tls_data[tls_data_len + 8] = (uint8_t) sni_len;
memcpy(tls_data + tls_data_len + 9, sni, sni_len);
tls_data_len += 9 + sni_len;
memcpy(tls_data + tls_data_len, tls_data2, tls_data2_len);
tls_data_len += tls_data2_len;
unsigned ticket_len = (unsigned) (xorshift128plus() % (uint64_t) 164) * 2 + 64;
tls_data[tls_data_len - 1] = (uint8_t) (ticket_len & 0xff);
tls_data[tls_data_len - 2] = (uint8_t) (ticket_len >> 8);
rand_bytes(tls_data + tls_data_len, ticket_len);
tls_data_len += ticket_len;
memcpy(tls_data + tls_data_len, tls_data3, tls_data3_len);
tls_data_len += tls_data3_len;
datalength = 11 + 32 + 1 + 32 + tls_data0_len + 2 + tls_data_len;
out_buffer = (char *) malloc((size_t) datalength);
char *pdata = out_buffer + datalength - tls_data_len;
int len = tls_data_len;
memcpy(pdata, tls_data, tls_data_len);
pdata[-1] = (char) tls_data_len;
pdata[-2] = (char) (tls_data_len >> 8);
pdata -= 2;
len += 2;
memcpy(pdata - tls_data0_len, tls_data0, tls_data0_len);
pdata -= tls_data0_len;
len += tls_data0_len;
memcpy(pdata - 32, global->local_client_id, 32);
pdata -= 32;
len += 32;
pdata[-1] = 0x20;
pdata -= 1;
len += 1;
tls12_ticket_pack_auth_data(global, &self->server, pdata - 32);
pdata -= 32;
len += 32;
pdata[-1] = 0x3;
pdata[-2] = 0x3; // tls version
pdata -= 2;
len += 2;
pdata[-1] = (char) len;
pdata[-2] = (char) (len >> 8);
pdata[-3] = 0;
pdata[-4] = 1;
pdata -= 4;
len += 4;
pdata[-1] = (char) len;
pdata[-2] = (char) (len >> 8);
pdata -= 2;
len += 2;
pdata[-1] = 0x1;
pdata[-2] = 0x3; // tls version
pdata -= 2;
len += 2;
pdata[-1] = 0x16; // tls handshake
pdata -= 1;
len += 1;
local->handshake_status = 1;
} else if (datalength == 0) {
datalength = local->send_buffer_size + 43;
out_buffer = (char *) malloc((size_t) datalength);
char *pdata = out_buffer;
memcpy(pdata, "\x14\x03\x03\x00\x01\x01", 6);
pdata += 6;
memcpy(pdata, "\x16\x03\x03\x00\x20", 5);
pdata += 5;
rand_bytes((uint8_t *) pdata, 22);
pdata += 22;
uint8_t *key = (uint8_t *) malloc(self->server.key_len + 32);
char hash[SHA1_BYTES];
memcpy(key, self->server.key, self->server.key_len);
memcpy(key + self->server.key_len, global->local_client_id, 32);
ss_sha1_hmac_with_key(hash, out_buffer, (int) (pdata - out_buffer), key, (int) (self->server.key_len + 32));
free(key);
memcpy(pdata, hash, OBFS_HMAC_SHA1_LEN);
pdata += OBFS_HMAC_SHA1_LEN;
memcpy(pdata, local->send_buffer, local->send_buffer_size);
free(local->send_buffer);
local->send_buffer = NULL;
local->handshake_status = 8;
} else {
return 0;
}
if ((int) *capacity < datalength) {
*pencryptdata = (char *) realloc(*pencryptdata, *capacity = (size_t) (datalength * 2));
encryptdata = *pencryptdata;
}
memmove(encryptdata, out_buffer, datalength);
free(out_buffer);
return datalength;
}
int
tls12_ticket_auth_client_decode(obfs *self, char **pencryptdata, int datalength, size_t *capacity, int *needsendback) {
char *encryptdata = *pencryptdata;
tls12_ticket_auth_local_data *local = (tls12_ticket_auth_local_data *) self->l_data;
tls12_ticket_auth_global_data *global = (tls12_ticket_auth_global_data *) self->server.g_data;
*needsendback = 0;
if (local->handshake_status == 8) {
local->recv_buffer_size += datalength;
local->recv_buffer = (char *) realloc(local->recv_buffer, (size_t) local->recv_buffer_size);
memcpy(local->recv_buffer + local->recv_buffer_size - datalength, encryptdata, datalength);
datalength = 0;
while (local->recv_buffer_size > 5) {
if (local->recv_buffer[0] != 0x17)
return -1;
int size = ((int) (unsigned char) local->recv_buffer[3] << 8) + (unsigned char) local->recv_buffer[4];
if (size + 5 > local->recv_buffer_size)
break;
if ((int) *capacity < datalength + size) {
*pencryptdata = (char *) realloc(*pencryptdata, *capacity = (size_t) ((datalength + size) * 2));
encryptdata = *pencryptdata;
}
memcpy(encryptdata + datalength, local->recv_buffer + 5, size);
datalength += size;
local->recv_buffer_size -= 5 + size;
memmove(local->recv_buffer, local->recv_buffer + 5 + size, local->recv_buffer_size);
}
return datalength;
}
if (datalength < 11 + 32 + 1 + 32) {
return -1;
}
uint8_t *key = (uint8_t *) malloc(self->server.key_len + 32);
char hash[SHA1_BYTES];
memcpy(key, self->server.key, self->server.key_len);
memcpy(key + self->server.key_len, global->local_client_id, 32);
ss_sha1_hmac_with_key(hash, encryptdata + 11, 22, key, (int) self->server.key_len + 32);
free(key);
if (memcmp(encryptdata + 33, hash, OBFS_HMAC_SHA1_LEN)) {
return -1;
}
*needsendback = 1;
return 0;
}
|
281677160/openwrt-package | 4,052 | luci-app-ssr-plus/shadowsocksr-libev/src/src/obfs/verify.c | #include <stdlib.h>
#include <string.h>
#include "verify.h"
#include "obfsutil.h"
#include "crc32.h"
static int verify_simple_pack_unit_size = 2000;
typedef struct verify_simple_local_data {
char * recv_buffer;
int recv_buffer_size;
}verify_simple_local_data;
void verify_simple_local_data_init(verify_simple_local_data* local) {
local->recv_buffer = (char*)malloc(16384);
local->recv_buffer_size = 0;
}
obfs * verify_simple_new_obfs() {
obfs * self = new_obfs();
self->l_data = malloc(sizeof(verify_simple_local_data));
verify_simple_local_data_init((verify_simple_local_data*)self->l_data);
return self;
}
void verify_simple_dispose(obfs *self) {
verify_simple_local_data *local = (verify_simple_local_data*)self->l_data;
if (local->recv_buffer != NULL) {
free(local->recv_buffer);
local->recv_buffer = NULL;
}
free(local);
self->l_data = NULL;
dispose_obfs(self);
}
int verify_simple_pack_data(char *data, int datalength, char *outdata) {
unsigned char rand_len = (xorshift128plus() & 0xF) + 1;
int out_size = rand_len + datalength + 6;
outdata[0] = (char)(out_size >> 8);
outdata[1] = (char)out_size;
outdata[2] = (char)rand_len;
memmove(outdata + rand_len + 2, data, datalength);
fillcrc32((unsigned char *)outdata, (unsigned int)out_size);
return out_size;
}
int verify_simple_client_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t *capacity) {
char *plaindata = *pplaindata;
//verify_simple_local_data *local = (verify_simple_local_data*)self->l_data;
char * out_buffer = (char*)malloc((size_t)(datalength * 2 + 32));
char * buffer = out_buffer;
char * data = plaindata;
int len = datalength;
int pack_len;
while ( len > verify_simple_pack_unit_size ) {
pack_len = verify_simple_pack_data(data, verify_simple_pack_unit_size, buffer);
buffer += pack_len;
data += verify_simple_pack_unit_size;
len -= verify_simple_pack_unit_size;
}
if (len > 0) {
pack_len = verify_simple_pack_data(data, len, buffer);
buffer += pack_len;
}
len = (int)(buffer - out_buffer);
if ((int)*capacity < len) {
*pplaindata = (char*)realloc(*pplaindata, *capacity = (size_t)(len * 2));
plaindata = *pplaindata;
}
memmove(plaindata, out_buffer, len);
free(out_buffer);
return len;
}
int verify_simple_client_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t *capacity) {
char *plaindata = *pplaindata;
verify_simple_local_data *local = (verify_simple_local_data*)self->l_data;
uint8_t * recv_buffer = (uint8_t *)local->recv_buffer;
if (local->recv_buffer_size + datalength > 16384)
return -1;
memmove(recv_buffer + local->recv_buffer_size, plaindata, datalength);
local->recv_buffer_size += datalength;
char * out_buffer = (char*)malloc((size_t)local->recv_buffer_size);
char * buffer = out_buffer;
while (local->recv_buffer_size > 2) {
int length = ((int)recv_buffer[0] << 8) | recv_buffer[1];
if (length >= 8192 || length < 7) {
free(out_buffer);
local->recv_buffer_size = 0;
return -1;
}
if (length > local->recv_buffer_size)
break;
int crc = (int)crc32((unsigned char*)recv_buffer, (unsigned int)length);
if (crc != -1) {
free(out_buffer);
local->recv_buffer_size = 0;
return -1;
}
int data_size = length - recv_buffer[2] - 6;
memmove(buffer, recv_buffer + 2 + recv_buffer[2], data_size);
buffer += data_size;
memmove(recv_buffer, recv_buffer + length, local->recv_buffer_size -= length);
}
int len = (int)(buffer - out_buffer);
if ((int)*capacity < len) {
*pplaindata = (char*)realloc(*pplaindata, *capacity = (size_t)(len * 2));
plaindata = *pplaindata;
}
memmove(plaindata, out_buffer, len);
free(out_buffer);
return len;
}
|
281677160/openwrt-package | 37,183 | luci-app-ssr-plus/shadowsocksr-libev/src/src/obfs/auth.c | #include <string.h>
#include <time.h>
#include "auth.h"
#include "obfsutil.h"
#include "crc32.h"
#include "base64.h"
#include "encrypt.h"
static int auth_simple_pack_unit_size = 2000;
typedef int (*hmac_with_key_func)(char *auth, char *msg, int msg_len, uint8_t *auth_key, int key_len);
typedef int (*hash_func)(char *auth, char *msg, int msg_len);
typedef struct auth_simple_global_data {
uint8_t local_client_id[8];
uint32_t connection_id;
}auth_simple_global_data;
typedef struct auth_simple_local_data {
int has_sent_header;
char * recv_buffer;
int recv_buffer_size;
uint32_t recv_id;
uint32_t pack_id;
char * salt;
uint8_t * user_key;
char uid[4];
int user_key_len;
hmac_with_key_func hmac;
hash_func hash;
int hash_len;
int last_data_len;
}auth_simple_local_data;
void auth_simple_local_data_init(auth_simple_local_data* local) {
local->has_sent_header = 0;
local->recv_buffer = (char*)malloc(16384);
local->recv_buffer_size = 0;
local->recv_id = 1;
local->pack_id = 1;
local->salt = "";
local->user_key = 0;
local->user_key_len = 0;
local->hmac = 0;
local->hash = 0;
local->hash_len = 0;
local->salt = "";
}
void * auth_simple_init_data() {
auth_simple_global_data *global = (auth_simple_global_data*)malloc(sizeof(auth_simple_global_data));
rand_bytes(global->local_client_id, 8);
rand_bytes((uint8_t*)&global->connection_id, 4);
global->connection_id &= 0xFFFFFF;
return global;
}
obfs * auth_simple_new_obfs() {
obfs * self = new_obfs();
self->l_data = malloc(sizeof(auth_simple_local_data));
auth_simple_local_data_init((auth_simple_local_data*)self->l_data);
return self;
}
obfs * auth_aes128_md5_new_obfs() {
obfs * self = new_obfs();
self->l_data = malloc(sizeof(auth_simple_local_data));
auth_simple_local_data_init((auth_simple_local_data*)self->l_data);
((auth_simple_local_data*)self->l_data)->hmac = ss_md5_hmac_with_key;
((auth_simple_local_data*)self->l_data)->hash = ss_md5_hash_func;
((auth_simple_local_data*)self->l_data)->hash_len = 16;
((auth_simple_local_data*)self->l_data)->salt = "auth_aes128_md5";
return self;
}
obfs * auth_aes128_sha1_new_obfs() {
obfs * self = new_obfs();
self->l_data = malloc(sizeof(auth_simple_local_data));
auth_simple_local_data_init((auth_simple_local_data*)self->l_data);
((auth_simple_local_data*)self->l_data)->hmac = ss_sha1_hmac_with_key;
((auth_simple_local_data*)self->l_data)->hash = ss_sha1_hash_func;
((auth_simple_local_data*)self->l_data)->hash_len = 20;
((auth_simple_local_data*)self->l_data)->salt = "auth_aes128_sha1";
return self;
}
int auth_aes128_sha1_get_overhead(obfs *self) {
return 9;
}
void auth_simple_dispose(obfs *self) {
auth_simple_local_data *local = (auth_simple_local_data*)self->l_data;
if (local->recv_buffer != NULL) {
free(local->recv_buffer);
local->recv_buffer = NULL;
}
if (local->user_key != NULL) {
free(local->user_key);
local->user_key = NULL;
}
free(local);
self->l_data = NULL;
dispose_obfs(self);
}
int auth_simple_pack_data(char *data, int datalength, char *outdata) {
unsigned char rand_len = (xorshift128plus() & 0xF) + 1;
int out_size = rand_len + datalength + 6;
outdata[0] = (char)(out_size >> 8);
outdata[1] = (char)(out_size);
outdata[2] = (char)(rand_len);
memmove(outdata + rand_len + 2, data, datalength);
fillcrc32((unsigned char *)outdata, (unsigned int)out_size);
return out_size;
}
int auth_simple_pack_auth_data(auth_simple_global_data *global, char *data, int datalength, char *outdata) {
unsigned char rand_len = (xorshift128plus() & 0xF) + 1;
int out_size = rand_len + datalength + 6 + 12;
outdata[0] = (char)(out_size >> 8);
outdata[1] = (char)(out_size);
outdata[2] = (char)(rand_len);
++global->connection_id;
if (global->connection_id > 0xFF000000) {
rand_bytes(global->local_client_id, 8);
rand_bytes((uint8_t*)&global->connection_id, 4);
global->connection_id &= 0xFFFFFF;
}
time_t t = time(NULL);
memintcopy_lt(outdata + rand_len + 2, (uint32_t)t);
memmove(outdata + rand_len + 2 + 4, global->local_client_id, 4);
memintcopy_lt(outdata + rand_len + 2 + 8, global->connection_id);
memmove(outdata + rand_len + 2 + 12, data, datalength);
fillcrc32((unsigned char *)outdata, (unsigned int)out_size);
return out_size;
}
int auth_simple_client_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity) {
char *plaindata = *pplaindata;
auth_simple_local_data *local = (auth_simple_local_data*)self->l_data;
char * out_buffer = (char*)malloc((size_t)(datalength * 2 + 64));
char * buffer = out_buffer;
char * data = plaindata;
int len = datalength;
int pack_len;
if (len > 0 && local->has_sent_header == 0) {
int head_size = get_head_size(plaindata, datalength, 30);
if (head_size > datalength)
head_size = datalength;
pack_len = auth_simple_pack_auth_data((auth_simple_global_data *)self->server.g_data, data, head_size, buffer);
buffer += pack_len;
data += head_size;
len -= head_size;
local->has_sent_header = 1;
}
while ( len > auth_simple_pack_unit_size ) {
pack_len = auth_simple_pack_data(data, auth_simple_pack_unit_size, buffer);
buffer += pack_len;
data += auth_simple_pack_unit_size;
len -= auth_simple_pack_unit_size;
}
if (len > 0) {
pack_len = auth_simple_pack_data(data, len, buffer);
buffer += pack_len;
}
len = (int)(buffer - out_buffer);
if ((int)(*capacity) < len) {
*pplaindata = (char*)realloc(*pplaindata, *capacity = (size_t)(len * 2));
plaindata = *pplaindata;
}
memmove(plaindata, out_buffer, len);
free(out_buffer);
return len;
}
int auth_simple_client_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity) {
char *plaindata = *pplaindata;
auth_simple_local_data *local = (auth_simple_local_data*)self->l_data;
uint8_t * recv_buffer = (uint8_t *)local->recv_buffer;
if (local->recv_buffer_size + datalength > 16384)
return -1;
memmove(recv_buffer + local->recv_buffer_size, plaindata, datalength);
local->recv_buffer_size += datalength;
char * out_buffer = (char*)malloc((size_t)local->recv_buffer_size);
char * buffer = out_buffer;
while (local->recv_buffer_size > 2) {
int length = ((int)recv_buffer[0] << 8) | recv_buffer[1];
if (length >= 8192 || length < 7) {
free(out_buffer);
local->recv_buffer_size = 0;
return -1;
}
if (length > local->recv_buffer_size)
break;
int crc = (int) crc32((unsigned char*)recv_buffer, (unsigned int)length);
if (crc != -1) {
free(out_buffer);
local->recv_buffer_size = 0;
return -1;
}
int data_size = length - recv_buffer[2] - 6;
memmove(buffer, recv_buffer + 2 + recv_buffer[2], data_size);
buffer += data_size;
memmove(recv_buffer, recv_buffer + length, local->recv_buffer_size -= length);
}
int len = (int)(buffer - out_buffer);
if ((int)*capacity < len) {
*pplaindata = (char*)realloc(*pplaindata, *capacity = (size_t)(len * 2));
plaindata = *pplaindata;
}
memmove(plaindata, out_buffer, len);
free(out_buffer);
return len;
}
int auth_sha1_pack_data(char *data, int datalength, char *outdata) {
unsigned char rand_len = (xorshift128plus() & 0xF) + 1;
int out_size = rand_len + datalength + 6;
outdata[0] = (char)(out_size >> 8);
outdata[1] = (char)out_size;
outdata[2] = (char)rand_len;
memmove(outdata + rand_len + 2, data, datalength);
filladler32((unsigned char *)outdata, (unsigned int)out_size);
return out_size;
}
int auth_sha1_pack_auth_data(auth_simple_global_data *global, server_info *server, char *data, int datalength, char *outdata) {
unsigned char rand_len = (xorshift128plus() & 0x7F) + 1;
int data_offset = rand_len + 4 + 2;
int out_size = data_offset + datalength + 12 + OBFS_HMAC_SHA1_LEN;
fillcrc32to((unsigned char *)server->key, (unsigned int)server->key_len, (unsigned char *)outdata);
outdata[4] = (char)(out_size >> 8);
outdata[5] = (char)out_size;
outdata[6] = (char)rand_len;
++global->connection_id;
if (global->connection_id > 0xFF000000) {
rand_bytes(global->local_client_id, 8);
rand_bytes((uint8_t*)&global->connection_id, 4);
global->connection_id &= 0xFFFFFF;
}
time_t t = time(NULL);
memintcopy_lt(outdata + data_offset, (uint32_t)t);
memmove(outdata + data_offset + 4, global->local_client_id, 4);
memintcopy_lt(outdata + data_offset + 8, global->connection_id);
memmove(outdata + data_offset + 12, data, datalength);
char hash[SHA1_BYTES];
ss_sha1_hmac(hash, outdata, out_size - OBFS_HMAC_SHA1_LEN, server->iv, (int)server->iv_len, server->key, (int)server->key_len);
memcpy(outdata + out_size - OBFS_HMAC_SHA1_LEN, hash, OBFS_HMAC_SHA1_LEN);
return out_size;
}
int auth_sha1_client_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity) {
char *plaindata = *pplaindata;
auth_simple_local_data *local = (auth_simple_local_data*)self->l_data;
char * out_buffer = (char*)malloc((size_t)(datalength * 2 + 256));
char * buffer = out_buffer;
char * data = plaindata;
int len = datalength;
int pack_len;
if (len > 0 && local->has_sent_header == 0) {
int head_size = get_head_size(plaindata, datalength, 30);
if (head_size > datalength)
head_size = datalength;
pack_len = auth_sha1_pack_auth_data((auth_simple_global_data *)self->server.g_data, &self->server, data, head_size, buffer);
buffer += pack_len;
data += head_size;
len -= head_size;
local->has_sent_header = 1;
}
while ( len > auth_simple_pack_unit_size ) {
pack_len = auth_sha1_pack_data(data, auth_simple_pack_unit_size, buffer);
buffer += pack_len;
data += auth_simple_pack_unit_size;
len -= auth_simple_pack_unit_size;
}
if (len > 0) {
pack_len = auth_sha1_pack_data(data, len, buffer);
buffer += pack_len;
}
len = (int)(buffer - out_buffer);
if ((int)*capacity < len) {
*pplaindata = (char*)realloc(*pplaindata, *capacity = (size_t)(len * 2));
plaindata = *pplaindata;
}
memmove(plaindata, out_buffer, len);
free(out_buffer);
return len;
}
int auth_sha1_client_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity) {
char *plaindata = *pplaindata;
auth_simple_local_data *local = (auth_simple_local_data*)self->l_data;
uint8_t * recv_buffer = (uint8_t *)local->recv_buffer;
if (local->recv_buffer_size + datalength > 16384)
return -1;
memmove(recv_buffer + local->recv_buffer_size, plaindata, datalength);
local->recv_buffer_size += datalength;
char * out_buffer = (char*)malloc((size_t)local->recv_buffer_size);
char * buffer = out_buffer;
while (local->recv_buffer_size > 2) {
int length = ((int)recv_buffer[0] << 8) | recv_buffer[1];
if (length >= 8192 || length < 7) {
free(out_buffer);
local->recv_buffer_size = 0;
return -1;
}
if (length > local->recv_buffer_size)
break;
if (checkadler32((unsigned char*)recv_buffer, (unsigned int)length) == 0) {
free(out_buffer);
local->recv_buffer_size = 0;
return -1;
}
int pos = recv_buffer[2] + 2;
int data_size = length - pos - 4;
memmove(buffer, recv_buffer + pos, data_size);
buffer += data_size;
memmove(recv_buffer, recv_buffer + length, local->recv_buffer_size -= length);
}
int len = (int)(buffer - out_buffer);
if ((int)*capacity < len) {
*pplaindata = (char*)realloc(*pplaindata, *capacity = (size_t)(len * 2));
plaindata = *pplaindata;
}
memmove(plaindata, out_buffer, len);
free(out_buffer);
return len;
}
int auth_sha1_v2_pack_data(char *data, int datalength, char *outdata) {
unsigned int rand_len = (datalength > 1300 ? 0 : datalength > 400 ? (xorshift128plus() & 0x7F) : (xorshift128plus() & 0x3FF)) + 1;
int out_size = (int)rand_len + datalength + 6;
outdata[0] = (char)(out_size >> 8);
outdata[1] = (char)out_size;
if (rand_len < 128)
{
outdata[2] = (char)rand_len;
}
else
{
outdata[2] = (char)0xFF;
outdata[3] = (char)(rand_len >> 8);
outdata[4] = (char)rand_len;
}
memmove(outdata + rand_len + 2, data, datalength);
filladler32((unsigned char *)outdata, (unsigned int)out_size);
return out_size;
}
int auth_sha1_v2_pack_auth_data(auth_simple_global_data *global, server_info *server, char *data, int datalength, char *outdata) {
unsigned int rand_len = (datalength > 1300 ? 0 : datalength > 400 ? (xorshift128plus() & 0x7F) : (xorshift128plus() & 0x3FF)) + 1;
int data_offset = (int)rand_len + 4 + 2;
int out_size = data_offset + datalength + 12 + OBFS_HMAC_SHA1_LEN;
const char* salt = "auth_sha1_v2";
int salt_len = (int) strlen(salt);
unsigned char *crc_salt = (unsigned char*)malloc((size_t)salt_len + server->key_len);
memcpy(crc_salt, salt, salt_len);
memcpy(crc_salt + salt_len, server->key, server->key_len);
fillcrc32to(crc_salt, (unsigned int)((size_t)salt_len + server->key_len), (unsigned char *)outdata);
free(crc_salt);
outdata[4] = (char)(out_size >> 8);
outdata[5] = (char)out_size;
if (rand_len < 128)
{
outdata[6] = (char)rand_len;
}
else
{
outdata[6] = (char)0xFF;
outdata[7] = (char)(rand_len >> 8);
outdata[8] = (char)rand_len;
}
++global->connection_id;
if (global->connection_id > 0xFF000000) {
rand_bytes(global->local_client_id, 8);
rand_bytes((uint8_t*)&global->connection_id, 4);
global->connection_id &= 0xFFFFFF;
}
memmove(outdata + data_offset, global->local_client_id, 8);
memintcopy_lt(outdata + data_offset + 8, global->connection_id);
memmove(outdata + data_offset + 12, data, datalength);
char hash[SHA1_BYTES];
ss_sha1_hmac(hash, outdata, out_size - OBFS_HMAC_SHA1_LEN, server->iv, (int)server->iv_len, server->key, (int)server->key_len);
memcpy(outdata + out_size - OBFS_HMAC_SHA1_LEN, hash, OBFS_HMAC_SHA1_LEN);
return out_size;
}
int auth_sha1_v2_client_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity) {
char *plaindata = *pplaindata;
auth_simple_local_data *local = (auth_simple_local_data*)self->l_data;
char * out_buffer = (char*)malloc((size_t)(datalength * 2 + 4096));
char * buffer = out_buffer;
char * data = plaindata;
int len = datalength;
int pack_len;
if (len > 0 && local->has_sent_header == 0) {
int head_size = get_head_size(plaindata, datalength, 30);
if (head_size > datalength)
head_size = datalength;
pack_len = auth_sha1_v2_pack_auth_data((auth_simple_global_data *)self->server.g_data, &self->server, data, head_size, buffer);
buffer += pack_len;
data += head_size;
len -= head_size;
local->has_sent_header = 1;
}
while ( len > auth_simple_pack_unit_size ) {
pack_len = auth_sha1_v2_pack_data(data, auth_simple_pack_unit_size, buffer);
buffer += pack_len;
data += auth_simple_pack_unit_size;
len -= auth_simple_pack_unit_size;
}
if (len > 0) {
pack_len = auth_sha1_v2_pack_data(data, len, buffer);
buffer += pack_len;
}
len = (int)(buffer - out_buffer);
if ((int)*capacity < len) {
*pplaindata = (char*)realloc(*pplaindata, *capacity = (size_t)(len * 2));
plaindata = *pplaindata;
}
memmove(plaindata, out_buffer, len);
free(out_buffer);
return len;
}
int auth_sha1_v2_client_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity) {
char *plaindata = *pplaindata;
auth_simple_local_data *local = (auth_simple_local_data*)self->l_data;
uint8_t * recv_buffer = (uint8_t *)local->recv_buffer;
if (local->recv_buffer_size + datalength > 16384)
return -1;
memmove(recv_buffer + local->recv_buffer_size, plaindata, datalength);
local->recv_buffer_size += datalength;
char * out_buffer = (char*)malloc((size_t)local->recv_buffer_size);
char * buffer = out_buffer;
char error = 0;
while (local->recv_buffer_size > 2) {
int length = ((int)recv_buffer[0] << 8) | recv_buffer[1];
if (length >= 8192 || length < 7) {
local->recv_buffer_size = 0;
error = 1;
break;
}
if (length > local->recv_buffer_size)
break;
if (checkadler32((unsigned char*)recv_buffer, (unsigned int)length) == 0) {
local->recv_buffer_size = 0;
error = 1;
break;
}
int pos = recv_buffer[2];
if (pos < 255)
{
pos += 2;
}
else
{
pos = ((recv_buffer[3] << 8) | recv_buffer[4]) + 2;
}
int data_size = length - pos - 4;
memmove(buffer, recv_buffer + pos, data_size);
buffer += data_size;
memmove(recv_buffer, recv_buffer + length, local->recv_buffer_size -= length);
}
int len;
if (error == 0) {
len = (int)(buffer - out_buffer);
if ((int)*capacity < len) {
*pplaindata = (char*)realloc(*pplaindata, *capacity = (size_t)(len * 2));
plaindata = *pplaindata;
}
memmove(plaindata, out_buffer, len);
} else {
len = -1;
}
free(out_buffer);
return len;
}
int auth_sha1_v4_pack_data(char *data, int datalength, char *outdata) {
unsigned int rand_len = (datalength > 1300 ? 0 : datalength > 400 ? (xorshift128plus() & 0x7F) : (xorshift128plus() & 0x3FF)) + 1;
int out_size = (int)rand_len + datalength + 8;
outdata[0] = (char)(out_size >> 8);
outdata[1] = (char)out_size;
uint32_t crc_val = crc32((unsigned char*)outdata, 2);
outdata[2] = (char)crc_val;
outdata[3] = (char)(crc_val >> 8);
if (rand_len < 128)
{
outdata[4] = (char)rand_len;
}
else
{
outdata[4] = (char)0xFF;
outdata[5] = (char)(rand_len >> 8);
outdata[6] = (char)rand_len;
}
memmove(outdata + rand_len + 4, data, datalength);
filladler32((unsigned char *)outdata, (unsigned int)out_size);
return out_size;
}
int auth_sha1_v4_pack_auth_data(auth_simple_global_data *global, server_info *server, char *data, int datalength, char *outdata) {
unsigned int rand_len = (datalength > 1300 ? 0 : datalength > 400 ? (xorshift128plus() & 0x7F) : (xorshift128plus() & 0x3FF)) + 1;
int data_offset = (int)rand_len + 4 + 2;
int out_size = data_offset + datalength + 12 + OBFS_HMAC_SHA1_LEN;
const char* salt = "auth_sha1_v4";
int salt_len = (int)strlen(salt);
unsigned char *crc_salt = (unsigned char*)malloc((size_t)salt_len + server->key_len + 2);
crc_salt[0] = (unsigned char)(outdata[0] = (char)(out_size >> 8));
crc_salt[1] = (unsigned char)(outdata[1] = (char)out_size);
memcpy(crc_salt + 2, salt, salt_len);
memcpy(crc_salt + salt_len + 2, server->key, server->key_len);
fillcrc32to(crc_salt, (unsigned int)((size_t)salt_len + server->key_len + 2), (unsigned char *)outdata + 2);
free(crc_salt);
if (rand_len < 128)
{
outdata[6] = (char)rand_len;
}
else
{
outdata[6] = (char)0xFF;
outdata[7] = (char)(rand_len >> 8);
outdata[8] = (char)rand_len;
}
++global->connection_id;
if (global->connection_id > 0xFF000000) {
rand_bytes(global->local_client_id, 8);
rand_bytes((uint8_t*)&global->connection_id, 4);
global->connection_id &= 0xFFFFFF;
}
time_t t = time(NULL);
memintcopy_lt(outdata + data_offset, (uint32_t)t);
memmove(outdata + data_offset + 4, global->local_client_id, 4);
memintcopy_lt(outdata + data_offset + 8, global->connection_id);
memmove(outdata + data_offset + 12, data, datalength);
char hash[SHA1_BYTES];
ss_sha1_hmac(hash, outdata, out_size - OBFS_HMAC_SHA1_LEN, server->iv, (int)server->iv_len, server->key, (int)server->key_len);
memcpy(outdata + out_size - OBFS_HMAC_SHA1_LEN, hash, OBFS_HMAC_SHA1_LEN);
return out_size;
}
int auth_sha1_v4_client_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity) {
char *plaindata = *pplaindata;
auth_simple_local_data *local = (auth_simple_local_data*)self->l_data;
char * out_buffer = (char*)malloc((size_t)(datalength * 2 + 4096));
char * buffer = out_buffer;
char * data = plaindata;
int len = datalength;
int pack_len;
if (len > 0 && local->has_sent_header == 0) {
int head_size = get_head_size(plaindata, datalength, 30);
if (head_size > datalength)
head_size = datalength;
pack_len = auth_sha1_v4_pack_auth_data((auth_simple_global_data *)self->server.g_data, &self->server, data, head_size, buffer);
buffer += pack_len;
data += head_size;
len -= head_size;
local->has_sent_header = 1;
}
while ( len > auth_simple_pack_unit_size ) {
pack_len = auth_sha1_v4_pack_data(data, auth_simple_pack_unit_size, buffer);
buffer += pack_len;
data += auth_simple_pack_unit_size;
len -= auth_simple_pack_unit_size;
}
if (len > 0) {
pack_len = auth_sha1_v4_pack_data(data, len, buffer);
buffer += pack_len;
}
len = (int)(buffer - out_buffer);
if ((int)*capacity < len) {
*pplaindata = (char*)realloc(*pplaindata, *capacity = (size_t)(len * 2));
plaindata = *pplaindata;
}
memmove(plaindata, out_buffer, len);
free(out_buffer);
return len;
}
int auth_sha1_v4_client_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity) {
char *plaindata = *pplaindata;
auth_simple_local_data *local = (auth_simple_local_data*)self->l_data;
uint8_t * recv_buffer = (uint8_t *)local->recv_buffer;
if (local->recv_buffer_size + datalength > 16384)
return -1;
memmove(recv_buffer + local->recv_buffer_size, plaindata, datalength);
local->recv_buffer_size += datalength;
char * out_buffer = (char*)malloc((size_t)local->recv_buffer_size);
char * buffer = out_buffer;
char error = 0;
while (local->recv_buffer_size > 4) {
uint32_t crc_val = crc32((unsigned char*)recv_buffer, 2);
if ((((uint32_t)recv_buffer[3] << 8) | recv_buffer[2]) != (crc_val & 0xffff)) {
local->recv_buffer_size = 0;
error = 1;
break;
}
int length = ((int)recv_buffer[0] << 8) | recv_buffer[1];
if (length >= 8192 || length < 7) {
local->recv_buffer_size = 0;
error = 1;
break;
}
if (length > local->recv_buffer_size)
break;
if (checkadler32((unsigned char*)recv_buffer, (unsigned int)length) == 0) {
local->recv_buffer_size = 0;
error = 1;
break;
}
int pos = recv_buffer[4];
if (pos < 255)
{
pos += 4;
}
else
{
pos = (((int)recv_buffer[5] << 8) | recv_buffer[6]) + 4;
}
int data_size = length - pos - 4;
memmove(buffer, recv_buffer + pos, data_size);
buffer += data_size;
memmove(recv_buffer, recv_buffer + length, local->recv_buffer_size -= length);
}
int len;
if (error == 0) {
len = (int)(buffer - out_buffer);
if ((int)*capacity < len) {
*pplaindata = (char*)realloc(*pplaindata, *capacity = (size_t)(len * 2));
plaindata = *pplaindata;
}
memmove(plaindata, out_buffer, len);
} else {
len = -1;
}
free(out_buffer);
return len;
}
unsigned int get_rand_len(int datalength, int fulldatalength, auth_simple_local_data *local, server_info *server) {
if (datalength > 1300 || local->last_data_len > 1300 || fulldatalength >= (int)server->buffer_size)
return 0;
if (datalength > 1100)
return xorshift128plus() & 0x7F;
if (datalength > 900)
return xorshift128plus() & 0xFF;
if (datalength > 400)
return xorshift128plus() & 0x1FF;
return xorshift128plus() & 0x3FF;
}
int auth_aes128_sha1_pack_data(char *data, int datalength, int fulldatalength, char *outdata, auth_simple_local_data *local, server_info *server) {
unsigned int rand_len = get_rand_len(datalength, fulldatalength, local, server) + 1;
int out_size = (int)rand_len + datalength + 8;
memcpy(outdata + rand_len + 4, data, datalength);
outdata[0] = (char)out_size;
outdata[1] = (char)(out_size >> 8);
uint8_t key_len = (uint8_t)(local->user_key_len + 4);
uint8_t *key = (uint8_t*)malloc(key_len);
memcpy(key, local->user_key, local->user_key_len);
memintcopy_lt(key + key_len - 4, local->pack_id);
{
uint8_t *rnd_data = (uint8_t *)malloc(rand_len);
rand_bytes(rnd_data, (int)rand_len);
memcpy(outdata + 4, rnd_data, rand_len);
free(rnd_data);
}
{
char hash[20];
local->hmac(hash, outdata, 2, key, key_len);
memcpy(outdata + 2, hash, 2);
}
if (rand_len < 128)
{
outdata[4] = (char)rand_len;
}
else
{
outdata[4] = (char)0xFF;
outdata[5] = (char)rand_len;
outdata[6] = (char)(rand_len >> 8);
}
++local->pack_id;
{
char hash[20];
local->hmac(hash, outdata, out_size - 4, key, key_len);
memcpy(outdata + out_size - 4, hash, 4);
}
free(key);
return out_size;
}
int auth_aes128_sha1_pack_auth_data(auth_simple_global_data *global, server_info *server, auth_simple_local_data *local, char *data, int datalength, char *outdata) {
unsigned int rand_len = (datalength > 400 ? (xorshift128plus() & 0x1FF) : (xorshift128plus() & 0x3FF));
int data_offset = (int)rand_len + 16 + 4 + 4 + 7;
int out_size = data_offset + datalength + 4;
const char* salt = local->salt;
char encrypt[24];
char encrypt_data[16];
uint8_t *key = (uint8_t*)malloc(server->iv_len + server->key_len);
uint8_t key_len = (uint8_t)(server->iv_len + server->key_len);
memcpy(key, server->iv, server->iv_len);
memcpy(key + server->iv_len, server->key, server->key_len);
{
uint8_t *rnd_data = (uint8_t *)malloc(rand_len);
rand_bytes(rnd_data, (int)rand_len);
memcpy(outdata + data_offset - rand_len, rnd_data, rand_len);
free(rnd_data);
}
++global->connection_id;
if (global->connection_id > 0xFF000000) {
rand_bytes(global->local_client_id, 8);
rand_bytes((uint8_t*)&global->connection_id, 4);
global->connection_id &= 0xFFFFFF;
}
time_t t = time(NULL);
memintcopy_lt(encrypt, (uint32_t)t);
memcpy(encrypt + 4, global->local_client_id, 4);
memintcopy_lt(encrypt + 8, global->connection_id);
encrypt[12] = (char)out_size;
encrypt[13] = (char)(out_size >> 8);
encrypt[14] = (char)rand_len;
encrypt[15] = (char)(rand_len >> 8);
{
if (local->user_key == NULL) {
if(server->param != NULL && server->param[0] != 0) {
char *param = server->param;
char *delim = strchr(param, ':');
if(delim != NULL) {
char uid_str[16] = "";
strncpy(uid_str, param, delim - param);
char key_str[128];
strcpy(key_str, delim + 1);
long uid_long = strtol(uid_str, NULL, 10);
memintcopy_lt(local->uid, (uint32_t)uid_long);
char hash[21] = {0};
local->hash(hash, key_str, (int)strlen(key_str));
local->user_key_len = local->hash_len;
local->user_key = (uint8_t*)malloc((size_t)local->user_key_len);
memcpy(local->user_key, hash, local->hash_len);
}
}
if (local->user_key == NULL) {
rand_bytes((uint8_t *)local->uid, 4);
local->user_key_len = (int)server->key_len;
local->user_key = (uint8_t*)malloc((size_t)local->user_key_len);
memcpy(local->user_key, server->key, local->user_key_len);
}
}
char encrypt_key_base64[256] = {0};
unsigned char *encrypt_key = (unsigned char *)malloc(local->user_key_len);
memcpy(encrypt_key, local->user_key, local->user_key_len);
base64_encode(encrypt_key, (unsigned int)local->user_key_len, encrypt_key_base64);
free(encrypt_key);
int base64_len;
base64_len = (local->user_key_len + 2) / 3 * 4;
memcpy(encrypt_key_base64 + base64_len, salt, strlen(salt));
char enc_key[16];
int enc_key_len = base64_len + (int)strlen(salt);
bytes_to_key_with_size(encrypt_key_base64, (size_t)enc_key_len, (uint8_t*)enc_key, 16);
ss_aes_128_cbc(encrypt, encrypt_data, enc_key);
memcpy(encrypt + 4, encrypt_data, 16);
memcpy(encrypt, local->uid, 4);
}
{
char hash[20];
local->hmac(hash, encrypt, 20, key, key_len);
memcpy(encrypt + 20, hash, 4);
}
{
rand_bytes((uint8_t*)outdata, 1);
char hash[20];
local->hmac(hash, (char *)outdata, 1, key, key_len);
memcpy(outdata + 1, hash, 6);
}
memcpy(outdata + 7, encrypt, 24);
memcpy(outdata + data_offset, data, datalength);
{
char hash[20];
local->hmac(hash, outdata, out_size - 4, local->user_key, local->user_key_len);
memmove(outdata + out_size - 4, hash, 4);
}
free(key);
return out_size;
}
int auth_aes128_sha1_client_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity) {
char *plaindata = *pplaindata;
auth_simple_local_data *local = (auth_simple_local_data*)self->l_data;
char * out_buffer = (char*)malloc((size_t)(datalength * 2 + 4096));
char * buffer = out_buffer;
char * data = plaindata;
int len = datalength;
int pack_len;
if (len > 0 && local->has_sent_header == 0) {
int head_size = 1200;
if (head_size > datalength)
head_size = datalength;
pack_len = auth_aes128_sha1_pack_auth_data((auth_simple_global_data *)self->server.g_data, &self->server, local, data, head_size, buffer);
buffer += pack_len;
data += head_size;
len -= head_size;
local->has_sent_header = 1;
}
while ( len > auth_simple_pack_unit_size ) {
pack_len = auth_aes128_sha1_pack_data(data, auth_simple_pack_unit_size, datalength, buffer, local, &self->server);
buffer += pack_len;
data += auth_simple_pack_unit_size;
len -= auth_simple_pack_unit_size;
}
if (len > 0) {
pack_len = auth_aes128_sha1_pack_data(data, len, datalength, buffer, local, &self->server);
buffer += pack_len;
}
len = (int)(buffer - out_buffer);
if ((int)*capacity < len) {
*pplaindata = (char*)realloc(*pplaindata, *capacity = (size_t)(len * 2));
plaindata = *pplaindata;
}
local->last_data_len = datalength;
memmove(plaindata, out_buffer, len);
free(out_buffer);
return len;
}
int auth_aes128_sha1_client_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity) {
char *plaindata = *pplaindata;
auth_simple_local_data *local = (auth_simple_local_data*)self->l_data;
//server_info *server = (server_info*)&self->server;
uint8_t * recv_buffer = (uint8_t *)local->recv_buffer;
if (local->recv_buffer_size + datalength > 16384)
return -1;
memmove(recv_buffer + local->recv_buffer_size, plaindata, datalength);
local->recv_buffer_size += datalength;
int key_len = local->user_key_len + 4;
uint8_t *key = (uint8_t*)malloc((size_t)key_len);
memcpy(key, local->user_key, local->user_key_len);
char * out_buffer = (char*)malloc((size_t)local->recv_buffer_size);
char * buffer = out_buffer;
char error = 0;
while (local->recv_buffer_size > 4) {
memintcopy_lt(key + key_len - 4, local->recv_id);
{
char hash[20];
local->hmac(hash, (char*)recv_buffer, 2, key, key_len);
if (memcmp(hash, recv_buffer + 2, 2)) {
local->recv_buffer_size = 0;
error = 1;
break;
}
}
int length = ((int)recv_buffer[1] << 8) + recv_buffer[0];
if (length >= 8192 || length < 8) {
local->recv_buffer_size = 0;
error = 1;
break;
}
if (length > local->recv_buffer_size)
break;
{
char hash[20];
local->hmac(hash, (char *)recv_buffer, length - 4, key, key_len);
if (memcmp(hash, recv_buffer + length - 4, 4))
{
local->recv_buffer_size = 0;
error = 1;
break;
}
}
++local->recv_id;
int pos = recv_buffer[4];
if (pos < 255)
{
pos += 4;
}
else
{
pos = (((int)recv_buffer[6] << 8) | recv_buffer[5]) + 4;
}
int data_size = length - pos - 4;
memmove(buffer, recv_buffer + pos, data_size);
buffer += data_size;
memmove(recv_buffer, recv_buffer + length, local->recv_buffer_size -= length);
}
int len;
if (error == 0) {
len = (int)(buffer - out_buffer);
if ((int)*capacity < len) {
*pplaindata = (char*)realloc(*pplaindata, *capacity = (size_t)(len * 2));
plaindata = *pplaindata;
}
memmove(plaindata, out_buffer, len);
} else {
len = -1;
}
free(out_buffer);
free(key);
return len;
}
int auth_aes128_sha1_client_udp_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity) {
char *plaindata = *pplaindata;
auth_simple_local_data *local = (auth_simple_local_data*)self->l_data;
char * out_buffer = (char*)malloc((size_t)(datalength + 8));
if (local->user_key == NULL) {
if(self->server.param != NULL && self->server.param[0] != 0) {
char *param = self->server.param;
char *delim = strchr(param, ':');
if(delim != NULL) {
char uid_str[16] = "";
strncpy(uid_str, param, delim - param);
char key_str[128];
strcpy(key_str, delim + 1);
long uid_long = strtol(uid_str, NULL, 10);
memintcopy_lt(local->uid, (uint32_t)uid_long);
char hash[21] = {0};
local->hash(hash, key_str, (int)strlen(key_str));
local->user_key_len = local->hash_len;
local->user_key = (uint8_t*)malloc((size_t)local->user_key_len);
memcpy(local->user_key, hash, local->hash_len);
}
}
if (local->user_key == NULL) {
rand_bytes((uint8_t *)local->uid, 4);
local->user_key_len = (int)self->server.key_len;
local->user_key = (uint8_t*)malloc((size_t)local->user_key_len);
memcpy(local->user_key, self->server.key, local->user_key_len);
}
}
int outlength = datalength + 8;
memmove(out_buffer, plaindata, datalength);
memmove(out_buffer + datalength, local->uid, 4);
{
char hash[20];
local->hmac(hash, out_buffer, outlength - 4, local->user_key, local->user_key_len);
memmove(out_buffer + outlength - 4, hash, 4);
}
if ((int)*capacity < outlength) {
*pplaindata = (char*)realloc(*pplaindata, *capacity = (size_t)(outlength * 2));
plaindata = *pplaindata;
}
memmove(plaindata, out_buffer, outlength);
free(out_buffer);
return outlength;
}
int auth_aes128_sha1_client_udp_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t* capacity) {
if (datalength <= 4)
return 0;
char *plaindata = *pplaindata;
auth_simple_local_data *local = (auth_simple_local_data*)self->l_data;
char hash[20];
local->hmac(hash, plaindata, datalength - 4, self->server.key, (int)self->server.key_len);
if (memcmp(hash, plaindata + datalength - 4, 4))
{
return 0;
}
return datalength - 4;
}
|
281677160/openwrt-package | 1,976 | luci-app-ssr-plus/shadowsocksr-libev/src/src/obfs/auth_chain.h | /*
* auth.h - Define shadowsocksR server's buffers and callbacks
*
* Copyright (C) 2015 - 2016, Break Wa11 <mmgac001@gmail.com>
*/
#ifndef _OBFS_AUTH_CHAIN_H
#define _OBFS_AUTH_CHAIN_H
#include "obfs.h"
void *auth_chain_a_init_data();
void *auth_chain_b_init_data();
void *auth_chain_c_init_data();
void *auth_chain_d_init_data();
void *auth_chain_e_init_data();
void *auth_chain_f_init_data();
obfs *auth_chain_a_new_obfs();
obfs *auth_chain_b_new_obfs();
obfs *auth_chain_c_new_obfs();
obfs *auth_chain_d_new_obfs();
obfs *auth_chain_e_new_obfs();
obfs *auth_chain_f_new_obfs();
void auth_chain_a_dispose(obfs *self);
void auth_chain_b_dispose(obfs *self);
void auth_chain_c_dispose(obfs *self);
void auth_chain_d_dispose(obfs *self);
void auth_chain_e_dispose(obfs *self);
void auth_chain_f_dispose(obfs *self);
void auth_chain_a_set_server_info(obfs *self, server_info *server);
void auth_chain_b_set_server_info(obfs *self, server_info *server);
void auth_chain_c_set_server_info(obfs *self, server_info *server);
void auth_chain_d_set_server_info(obfs *self, server_info *server);
void auth_chain_e_set_server_info(obfs *self, server_info *server);
void auth_chain_f_set_server_info(obfs *self, server_info *server);
int auth_chain_a_client_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t *capacity);
int auth_chain_a_client_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t *capacity);
int auth_chain_a_client_udp_pre_encrypt(obfs *self, char **pplaindata, int datalength, size_t *capacity);
int auth_chain_a_client_udp_post_decrypt(obfs *self, char **pplaindata, int datalength, size_t *capacity);
int auth_chain_a_get_overhead(obfs *self);
int auth_chain_b_get_overhead(obfs *self);
int auth_chain_c_get_overhead(obfs *self);
int auth_chain_d_get_overhead(obfs *self);
int auth_chain_e_get_overhead(obfs *self);
int auth_chain_f_get_overhead(obfs *self);
#endif // _OBFS_AUTH_CHAIN_H
|
281677160/openwrt-package | 1,999 | luci-app-ssr-plus/shadowsocksr-libev/src/src/obfs/obfsutil.c | #include <stdint.h>
#include <time.h>
#include "obfsutil.h"
#include "encrypt.h"
int get_head_size(char *plaindata, int size, int def_size) {
if (plaindata == NULL || size < 2)
return def_size;
int head_type = plaindata[0] & 0x7;
if (head_type == 1)
return 7;
if (head_type == 4)
return 19;
if (head_type == 3)
return 4 + plaindata[1];
return def_size;
}
static int shift128plus_init_flag = 0;
static uint64_t shift128plus_s[2] = {0x10000000, 0xFFFFFFFF};
void init_shift128plus(void) {
if (shift128plus_init_flag == 0) {
shift128plus_init_flag = 1;
uint32_t seed = (uint32_t)time(NULL);
shift128plus_s[0] = seed | 0x100000000L;
shift128plus_s[1] = ((uint64_t)seed << 32) | 0x1;
}
}
uint64_t xorshift128plus(void) {
uint64_t x = shift128plus_s[0];
uint64_t const y = shift128plus_s[1];
shift128plus_s[0] = y;
x ^= x << 23; // a
x ^= x >> 17; // b
x ^= y ^ (y >> 26); // c
shift128plus_s[1] = x;
return x + y;
}
int ss_md5_hmac(char *auth, char *msg, int msg_len, uint8_t *iv, int enc_iv_len, uint8_t *enc_key, int enc_key_len)
{
uint8_t auth_key[MAX_IV_LENGTH + MAX_KEY_LENGTH];
memcpy(auth_key, iv, enc_iv_len);
memcpy(auth_key + enc_iv_len, enc_key, enc_key_len);
return ss_md5_hmac_with_key(auth, msg, msg_len, auth_key, enc_iv_len + enc_key_len);
}
int ss_sha1_hmac(char *auth, char *msg, int msg_len, uint8_t *iv, int enc_iv_len, uint8_t *enc_key, int enc_key_len)
{
uint8_t auth_key[MAX_IV_LENGTH + MAX_KEY_LENGTH];
memcpy(auth_key, iv, enc_iv_len);
memcpy(auth_key + enc_iv_len, enc_key, enc_key_len);
return ss_sha1_hmac_with_key(auth, msg, msg_len, auth_key, enc_iv_len + enc_key_len);
}
void memintcopy_lt(void *mem, uint32_t val) {
((uint8_t *)mem)[0] = (uint8_t)(val);
((uint8_t *)mem)[1] = (uint8_t)(val >> 8);
((uint8_t *)mem)[2] = (uint8_t)(val >> 16);
((uint8_t *)mem)[3] = (uint8_t)(val >> 24);
}
|
281677160/openwrt-package | 1,314 | luci-app-ssr-plus/shadowsocksr-libev/src/completions/bash/ss-tunnel | _ss_tunnel()
{
local cur prev opts ciphers
ciphers='rc4-md5 table rc4 aes-128-cfb aes-192-cfb aes-256-cfb aes-128-ctr aes-192-ctr aes-256-ctr bf-cfb camellia-128-cfb camellia-192-cfb camellia-256-cfb cast5-cfb des-cfb idea-cfb rc2-cfb seed-cfb salsa20 chacha20 and chacha20-ietf'
opts='-s -b -p -k -f -t -m -c -a -n -u -U -v -h -A --mtu --help --mptcp -i -l -L'
cur=${COMP_WORDS[COMP_CWORD]}
prev="${COMP_WORDS[COMP_CWORD-1]}"
compopt +o nospace
case "$prev" in
-c|-f)
_filedir || COMPREPLY=( $(compgen -o plusdirs -f ${cur}) )
;;
-s|-b)
_known_hosts_real -- "${cur}" || OMPREPLY=( $(compgen -A hostname -- ${cur}) )
;;
-L)
compopt -o nospace
_known_hosts_real -c -- "${cur}" || OMPREPLY=( $(compgen -A hostname -S : -- ${cur}) )
;;
-m)
COMPREPLY=( $(compgen -W "$ciphers" -- ${cur}) )
;;
-a)
_allowed_users || COMPREPLY=( $(compgen -u -- ${cur}) )
;;
-p|-k|-t|-n|--mtu|-l)
;;
-i)
_available_interfaces -a || true
;;
*)
COMPREPLY+=( $(compgen -W "${opts}" -- ${cur}) )
;;
esac
return 0
}
complete -F _ss_tunnel ss-tunnel
|
281677160/openwrt-package | 1,053 | luci-app-ssr-plus/shadowsocksr-libev/src/completions/bash/ss-redir | _ss_redir()
{
local cur prev opts ciphers
ciphers='rc4-md5 table rc4 aes-128-cfb aes-192-cfb aes-256-cfb aes-128-ctr aes-192-ctr aes-256-ctr bf-cfb camellia-128-cfb camellia-192-cfb camellia-256-cfb cast5-cfb des-cfb idea-cfb rc2-cfb seed-cfb salsa20 chacha20 and chacha20-ietf'
opts='-s -b -p -k -f -t -m -c -a -n -u -U -v -h -A --mtu --help --mptcp -l'
cur=${COMP_WORDS[COMP_CWORD]}
prev="${COMP_WORDS[COMP_CWORD-1]}"
case "$prev" in
-c|-f)
_filedir || COMPREPLY=( $(compgen -o plusdirs -f ${cur}) )
;;
-s|-b)
_known_hosts_real -- "${cur}" || OMPREPLY=( $(compgen -A hostname -- ${cur}) )
;;
-m)
COMPREPLY=( $(compgen -W "$ciphers" -- ${cur}) )
;;
-a)
_allowed_users || COMPREPLY=( $(compgen -u -- ${cur}) )
;;
-p|-k|-t|-n|--mtu|-l)
;;
*)
COMPREPLY+=( $(compgen -W "${opts}" -- ${cur}) )
;;
esac
return 0
}
complete -F _ss_redir ss-redir
|
281677160/openwrt-package | 1,540 | luci-app-ssr-plus/shadowsocksr-libev/src/completions/bash/ss-manager | _ss_manager()
{
local cur prev opts ciphers
opts='-s -b -p -k -f -t -m -c -a -n -u -U -v -h -A --mtu --help --mptcp -i -l --manager-address --executable'
ciphers='rc4-md5 table rc4 aes-128-cfb aes-192-cfb aes-256-cfb aes-128-ctr aes-192-ctr aes-256-ctr bf-cfb camellia-128-cfb camellia-192-cfb camellia-256-cfb cast5-cfb des-cfb idea-cfb rc2-cfb seed-cfb salsa20 chacha20 and chacha20-ietf'
cur=${COMP_WORDS[COMP_CWORD]}
prev="${COMP_WORDS[COMP_CWORD-1]}"
case "$prev" in
-c|-f|--executable)
_filedir || COMPREPLY=( $(compgen -o plusdirs -f ${cur}) )
;;
-s|-b)
_known_hosts_real -- "${cur}" || OMPREPLY=( $(compgen -A hostname -- ${cur}) )
;;
-L)
compopt -o nospace
_known_hosts_real -c -- "${cur}" || OMPREPLY=( $(compgen -A hostname -S : -- ${cur}) )
;;
-m)
COMPREPLY=( $(compgen -W "$ciphers" -- ${cur}) )
;;
-a)
_allowed_users || COMPREPLY=( $(compgen -u -- ${cur}) )
;;
-p|-k|-t|-n|--mtu|-l)
;;
-i)
_available_interfaces -a || true
;;
--manager-address)
_known_hosts_real -- "${cur}" || OMPREPLY=( $(compgen -A hostname -- ${cur}) )
_filedir || COMPREPLY+=( $(compgen -o plusdirs -f ${cur}) )
;;
*)
COMPREPLY+=( $(compgen -W "${opts}" -- ${cur}) )
;;
esac
return 0
}
complete -F _ss_manager ss-manager
|
281677160/openwrt-package | 1,152 | luci-app-ssr-plus/shadowsocksr-libev/src/completions/bash/ss-local | _ss_local()
{
local cur prev opts ciphers
opts='-s -b -p -k -f -t -m -c -a -n -u -U -v -h -A --fast-open --mtu --help --mptcp -i --acl -l'
ciphers='rc4-md5 table rc4 aes-128-cfb aes-192-cfb aes-256-cfb aes-128-ctr aes-192-ctr aes-256-ctr bf-cfb camellia-128-cfb camellia-192-cfb camellia-256-cfb cast5-cfb des-cfb idea-cfb rc2-cfb seed-cfb salsa20 chacha20 and chacha20-ietf'
cur=${COMP_WORDS[COMP_CWORD]}
prev="${COMP_WORDS[COMP_CWORD-1]}"
case "$prev" in
-c|-f|--acl)
_filedir || COMPREPLY=( $(compgen -o plusdirs -f ${cur}) )
;;
-s|-b)
_known_hosts_real -- "${cur}" || OMPREPLY=( $(compgen -A hostname -- ${cur}) )
;;
-m)
COMPREPLY=( $(compgen -W "$ciphers" -- ${cur}) )
;;
-a)
_allowed_users || COMPREPLY=( $(compgen -u -- ${cur}) )
;;
-p|-k|-t|-n|--mtu|-l)
;;
-i)
_available_interfaces -a || true
;;
*)
COMPREPLY+=( $(compgen -W "${opts}" -- ${cur}) )
;;
esac
return 0
}
complete -F _ss_local ss-local
|
281677160/openwrt-package | 1,395 | luci-app-ssr-plus/shadowsocksr-libev/src/completions/bash/ss-server | _ss_server()
{
local cur prev opts ciphers
opts='-s -b -p -k -f -t -m -c -a -n -u -U -v -h -A --fast-open --mtu --help --mptcp -i -6 -d --manager-address --firewall --acl'
ciphers='rc4-md5 table rc4 aes-128-cfb aes-192-cfb aes-256-cfb aes-128-ctr aes-192-ctr aes-256-ctr bf-cfb camellia-128-cfb camellia-192-cfb camellia-256-cfb cast5-cfb des-cfb idea-cfb rc2-cfb seed-cfb salsa20 chacha20 and chacha20-ietf'
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev="${COMP_WORDS[COMP_CWORD-1]}"
case "$prev" in
-c|-f|--acl)
_filedir || COMPREPLY=( $(compgen -o plusdirs -f ${cur}) )
;;
-s|-b)
_known_hosts_real -- "${cur}" || OMPREPLY=( $(compgen -A hostname -- ${cur}) )
;;
-m)
COMPREPLY=( $(compgen -W "$ciphers" -- ${cur}) )
;;
-a)
_allowed_users || COMPREPLY=( $(compgen -u -- ${cur}) )
;;
-p|-k|-t|-n|--mtu|-d)
;;
--manager-address)
_known_hosts_real -- "${cur}" || OMPREPLY=( $(compgen -A hostname -- ${cur}) )
_filedir || COMPREPLY+=( $(compgen -o plusdirs -f ${cur}) )
;;
-i)
_available_interfaces -a || true
;;
*)
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
;;
esac
}
complete -F _ss_server ss-server
|
281677160/openwrt-package | 3,338 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/m4/ax_check_compile_flag.m4 | # ===========================================================================
# http://www.gnu.org/software/autoconf-archive/ax_check_compile_flag.html
# ===========================================================================
#
# SYNOPSIS
#
# AX_CHECK_COMPILE_FLAG(FLAG, [ACTION-SUCCESS], [ACTION-FAILURE], [EXTRA-FLAGS])
#
# DESCRIPTION
#
# Check whether the given FLAG works with the current language's compiler
# or gives an error. (Warnings, however, are ignored)
#
# ACTION-SUCCESS/ACTION-FAILURE are shell commands to execute on
# success/failure.
#
# If EXTRA-FLAGS is defined, it is added to the current language's default
# flags (e.g. CFLAGS) when the check is done. The check is thus made with
# the flags: "CFLAGS EXTRA-FLAGS FLAG". This can for example be used to
# force the compiler to issue an error when a bad flag is given.
#
# NOTE: Implementation based on AX_CFLAGS_GCC_OPTION. Please keep this
# macro in sync with AX_CHECK_{PREPROC,LINK}_FLAG.
#
# LICENSE
#
# Copyright (c) 2008 Guido U. Draheim <guidod@gmx.de>
# Copyright (c) 2011 Maarten Bosmans <mkbosmans@gmail.com>
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
# Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
#
# As a special exception, the respective Autoconf Macro's copyright owner
# gives unlimited permission to copy, distribute and modify the configure
# scripts that are the output of Autoconf when processing the Macro. You
# need not follow the terms of the GNU General Public License when using
# or distributing such scripts, even though portions of the text of the
# Macro appear in them. The GNU General Public License (GPL) does govern
# all other use of the material that constitutes the Autoconf Macro.
#
# This special exception to the GPL applies to versions of the Autoconf
# Macro released by the Autoconf Archive. When you make and distribute a
# modified version of the Autoconf Macro, you may extend this special
# exception to the GPL to apply to your modified version as well.
#serial 2
AC_DEFUN([AX_CHECK_COMPILE_FLAG],
[AC_PREREQ(2.64)dnl for _AC_LANG_PREFIX and AS_VAR_IF
AS_VAR_PUSHDEF([CACHEVAR],[ax_cv_check_[]_AC_LANG_ABBREV[]flags_$4_$1])dnl
AC_CACHE_CHECK([whether _AC_LANG compiler accepts $1], CACHEVAR, [
ax_check_save_flags=$[]_AC_LANG_PREFIX[]FLAGS
_AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS $4 $1"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdio.h>]],
[[char x[42U], fodder = 0;if (fodder > -1000 && fgets(x,1000,stdin)) puts(x)]])],
[AS_VAR_SET(CACHEVAR,[yes])],
[AS_VAR_SET(CACHEVAR,[no])])
_AC_LANG_PREFIX[]FLAGS=$ax_check_save_flags])
AS_VAR_IF(CACHEVAR,yes,
[m4_default([$2], :)],
[m4_default([$3], :)])
AS_VAR_POPDEF([CACHEVAR])dnl
])dnl AX_CHECK_COMPILE_FLAGS
|
281677160/openwrt-package | 7,798 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/m4/pkg.m4 | # pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*-
# serial 1 (pkg-config-0.24)
#
# Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
# PKG_PROG_PKG_CONFIG([MIN-VERSION])
# ----------------------------------
AC_DEFUN([PKG_PROG_PKG_CONFIG],
[m4_pattern_forbid([^_?PKG_[A-Z_]+$])
m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$])
m4_pattern_allow([^PKG_CONFIG_(DISABLE_UNINSTALLED|TOP_BUILD_DIR|DEBUG_SPEW)$])
AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])
AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path])
AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path])
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
AC_PATH_TOOL([PKG_CONFIG], [pkg-config])
fi
if test -n "$PKG_CONFIG"; then
_pkg_min_version=m4_default([$1], [0.9.0])
AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version])
if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
AC_MSG_RESULT([yes])
else
AC_MSG_RESULT([no])
PKG_CONFIG=""
fi
fi[]dnl
])# PKG_PROG_PKG_CONFIG
# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
#
# Check to see whether a particular set of modules exists. Similar
# to PKG_CHECK_MODULES(), but does not set variables or print errors.
#
# Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG])
# only at the first occurence in configure.ac, so if the first place
# it's called might be skipped (such as if it is within an "if", you
# have to call PKG_CHECK_EXISTS manually
# --------------------------------------------------------------
AC_DEFUN([PKG_CHECK_EXISTS],
[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
if test -n "$PKG_CONFIG" && \
AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then
m4_default([$2], [:])
m4_ifvaln([$3], [else
$3])dnl
fi])
# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
# ---------------------------------------------
m4_define([_PKG_CONFIG],
[if test -n "$$1"; then
pkg_cv_[]$1="$$1"
elif test -n "$PKG_CONFIG"; then
PKG_CHECK_EXISTS([$3],
[pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null`
test "x$?" != "x0" && pkg_failed=yes ],
[pkg_failed=yes])
else
pkg_failed=untried
fi[]dnl
])# _PKG_CONFIG
# _PKG_SHORT_ERRORS_SUPPORTED
# -----------------------------
AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED],
[AC_REQUIRE([PKG_PROG_PKG_CONFIG])
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
_pkg_short_errors_supported=yes
else
_pkg_short_errors_supported=no
fi[]dnl
])# _PKG_SHORT_ERRORS_SUPPORTED
# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
# [ACTION-IF-NOT-FOUND])
#
#
# Note that if there is a possibility the first call to
# PKG_CHECK_MODULES might not happen, you should be sure to include an
# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
#
#
# --------------------------------------------------------------
AC_DEFUN([PKG_CHECK_MODULES],
[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl
pkg_failed=no
AC_MSG_CHECKING([for $1])
_PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
_PKG_CONFIG([$1][_LIBS], [libs], [$2])
m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS
and $1[]_LIBS to avoid the need to call pkg-config.
See the pkg-config man page for more details.])
if test $pkg_failed = yes; then
AC_MSG_RESULT([no])
_PKG_SHORT_ERRORS_SUPPORTED
if test $_pkg_short_errors_supported = yes; then
$1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1`
else
$1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1`
fi
# Put the nasty error message in config.log where it belongs
echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD
m4_default([$4], [AC_MSG_ERROR(
[Package requirements ($2) were not met:
$$1_PKG_ERRORS
Consider adjusting the PKG_CONFIG_PATH environment variable if you
installed software in a non-standard prefix.
_PKG_TEXT])[]dnl
])
elif test $pkg_failed = untried; then
AC_MSG_RESULT([no])
m4_default([$4], [AC_MSG_FAILURE(
[The pkg-config script could not be found or is too old. Make sure it
is in your PATH or set the PKG_CONFIG environment variable to the full
path to pkg-config.
_PKG_TEXT
To get pkg-config, see <http://pkg-config.freedesktop.org/>.])[]dnl
])
else
$1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
$1[]_LIBS=$pkg_cv_[]$1[]_LIBS
AC_MSG_RESULT([yes])
$3
fi[]dnl
])# PKG_CHECK_MODULES
# PKG_INSTALLDIR(DIRECTORY)
# -------------------------
# Substitutes the variable pkgconfigdir as the location where a module
# should install pkg-config .pc files. By default the directory is
# $libdir/pkgconfig, but the default can be changed by passing
# DIRECTORY. The user can override through the --with-pkgconfigdir
# parameter.
AC_DEFUN([PKG_INSTALLDIR],
[m4_pushdef([pkg_default], [m4_default([$1], ['${libdir}/pkgconfig'])])
m4_pushdef([pkg_description],
[pkg-config installation directory @<:@]pkg_default[@:>@])
AC_ARG_WITH([pkgconfigdir],
[AS_HELP_STRING([--with-pkgconfigdir], pkg_description)],,
[with_pkgconfigdir=]pkg_default)
AC_SUBST([pkgconfigdir], [$with_pkgconfigdir])
m4_popdef([pkg_default])
m4_popdef([pkg_description])
]) dnl PKG_INSTALLDIR
# PKG_NOARCH_INSTALLDIR(DIRECTORY)
# -------------------------
# Substitutes the variable noarch_pkgconfigdir as the location where a
# module should install arch-independent pkg-config .pc files. By
# default the directory is $datadir/pkgconfig, but the default can be
# changed by passing DIRECTORY. The user can override through the
# --with-noarch-pkgconfigdir parameter.
AC_DEFUN([PKG_NOARCH_INSTALLDIR],
[m4_pushdef([pkg_default], [m4_default([$1], ['${datadir}/pkgconfig'])])
m4_pushdef([pkg_description],
[pkg-config arch-independent installation directory @<:@]pkg_default[@:>@])
AC_ARG_WITH([noarch-pkgconfigdir],
[AS_HELP_STRING([--with-noarch-pkgconfigdir], pkg_description)],,
[with_noarch_pkgconfigdir=]pkg_default)
AC_SUBST([noarch_pkgconfigdir], [$with_noarch_pkgconfigdir])
m4_popdef([pkg_default])
m4_popdef([pkg_description])
]) dnl PKG_NOARCH_INSTALLDIR
# PKG_CHECK_VAR(VARIABLE, MODULE, CONFIG-VARIABLE,
# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
# -------------------------------------------
# Retrieves the value of the pkg-config variable for the given module.
AC_DEFUN([PKG_CHECK_VAR],
[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
AC_ARG_VAR([$1], [value of $3 for $2, overriding pkg-config])dnl
_PKG_CONFIG([$1], [variable="][$3]["], [$2])
AS_VAR_COPY([$1], [pkg_cv_][$1])
AS_VAR_IF([$1], [""], [$5], [$4])dnl
])# PKG_CHECK_VAR
|
281677160/openwrt-package | 2,825 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/m4/ax_check_gnu_make.m4 | # ===========================================================================
# http://www.gnu.org/software/autoconf-archive/ax_check_gnu_make.html
# ===========================================================================
#
# SYNOPSIS
#
# AX_CHECK_GNU_MAKE()
#
# DESCRIPTION
#
# This macro searches for a GNU version of make. If a match is found, the
# makefile variable `ifGNUmake' is set to the empty string, otherwise it
# is set to "#". This is useful for including a special features in a
# Makefile, which cannot be handled by other versions of make. The
# variable _cv_gnu_make_command is set to the command to invoke GNU make
# if it exists, the empty string otherwise.
#
# Here is an example of its use:
#
# Makefile.in might contain:
#
# # A failsafe way of putting a dependency rule into a makefile
# $(DEPEND):
# $(CC) -MM $(srcdir)/*.c > $(DEPEND)
#
# @ifGNUmake@ ifeq ($(DEPEND),$(wildcard $(DEPEND)))
# @ifGNUmake@ include $(DEPEND)
# @ifGNUmake@ endif
#
# Then configure.in would normally contain:
#
# AX_CHECK_GNU_MAKE()
# AC_OUTPUT(Makefile)
#
# Then perhaps to cause gnu make to override any other make, we could do
# something like this (note that GNU make always looks for GNUmakefile
# first):
#
# if ! test x$_cv_gnu_make_command = x ; then
# mv Makefile GNUmakefile
# echo .DEFAULT: > Makefile ;
# echo \ $_cv_gnu_make_command \$@ >> Makefile;
# fi
#
# Then, if any (well almost any) other make is called, and GNU make also
# exists, then the other make wraps the GNU make.
#
# LICENSE
#
# Copyright (c) 2008 John Darrington <j.darrington@elvis.murdoch.edu.au>
#
# Copying and distribution of this file, with or without modification, are
# permitted in any medium without royalty provided the copyright notice
# and this notice are preserved. This file is offered as-is, without any
# warranty.
#serial 7
AC_DEFUN([AX_CHECK_GNU_MAKE], [ AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command,
_cv_gnu_make_command='' ;
dnl Search all the common names for GNU make
for a in "$MAKE" make gmake gnumake ; do
if test -z "$a" ; then continue ; fi ;
if ( sh -c "$a --version" 2> /dev/null | grep GNU 2>&1 > /dev/null ) ; then
_cv_gnu_make_command=$a ;
break;
fi
done ;
) ;
dnl If there was a GNU version, then set @ifGNUmake@ to the empty string, '#' otherwise
if test "x$_cv_gnu_make_command" != "x" ; then
ifGNUmake='' ;
else
ifGNUmake='#' ;
AC_MSG_RESULT("Not found");
fi
AC_SUBST(ifGNUmake)
] )
|
281677160/openwrt-package | 3,162 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/m4/ax_check_link_flag.m4 | # ===========================================================================
# http://www.gnu.org/software/autoconf-archive/ax_check_link_flag.html
# ===========================================================================
#
# SYNOPSIS
#
# AX_CHECK_LINK_FLAG(FLAG, [ACTION-SUCCESS], [ACTION-FAILURE], [EXTRA-FLAGS])
#
# DESCRIPTION
#
# Check whether the given FLAG works with the linker or gives an error.
# (Warnings, however, are ignored)
#
# ACTION-SUCCESS/ACTION-FAILURE are shell commands to execute on
# success/failure.
#
# If EXTRA-FLAGS is defined, it is added to the linker's default flags
# when the check is done. The check is thus made with the flags: "LDFLAGS
# EXTRA-FLAGS FLAG". This can for example be used to force the linker to
# issue an error when a bad flag is given.
#
# NOTE: Implementation based on AX_CFLAGS_GCC_OPTION. Please keep this
# macro in sync with AX_CHECK_{PREPROC,COMPILE}_FLAG.
#
# LICENSE
#
# Copyright (c) 2008 Guido U. Draheim <guidod@gmx.de>
# Copyright (c) 2011 Maarten Bosmans <mkbosmans@gmail.com>
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
# Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
#
# As a special exception, the respective Autoconf Macro's copyright owner
# gives unlimited permission to copy, distribute and modify the configure
# scripts that are the output of Autoconf when processing the Macro. You
# need not follow the terms of the GNU General Public License when using
# or distributing such scripts, even though portions of the text of the
# Macro appear in them. The GNU General Public License (GPL) does govern
# all other use of the material that constitutes the Autoconf Macro.
#
# This special exception to the GPL applies to versions of the Autoconf
# Macro released by the Autoconf Archive. When you make and distribute a
# modified version of the Autoconf Macro, you may extend this special
# exception to the GPL to apply to your modified version as well.
#serial 2
AC_DEFUN([AX_CHECK_LINK_FLAG],
[AC_PREREQ(2.64)dnl for _AC_LANG_PREFIX and AS_VAR_IF
AS_VAR_PUSHDEF([CACHEVAR],[ax_cv_check_ldflags_$4_$1])dnl
AC_CACHE_CHECK([whether the linker accepts $1], CACHEVAR, [
ax_check_save_flags=$LDFLAGS
LDFLAGS="$LDFLAGS $4 $1"
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdio.h>]],
[[char x[42U];if (fgets(x,1000,stdin)) puts(x)]])],
[AS_VAR_SET(CACHEVAR,[yes])],
[AS_VAR_SET(CACHEVAR,[no])])
LDFLAGS=$ax_check_save_flags])
AS_VAR_IF(CACHEVAR,yes,
[m4_default([$2], :)],
[m4_default([$3], :)])
AS_VAR_POPDEF([CACHEVAR])dnl
])dnl AX_CHECK_LINK_FLAGS
|
281677160/openwrt-package | 1,054 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/m4/ld-output-def.m4 | # ld-output-def.m4 serial 2
dnl Copyright (C) 2008-2013 Free Software Foundation, Inc.
dnl This file is free software; the Free Software Foundation
dnl gives unlimited permission to copy and/or distribute it,
dnl with or without modifications, as long as this notice is preserved.
dnl From Simon Josefsson
# gl_LD_OUTPUT_DEF()
# -------------
# Check if linker supports -Wl,--output-def and define automake
# conditional HAVE_LD_OUTPUT_DEF if it is.
AC_DEFUN([gl_LD_OUTPUT_DEF],
[
AC_CACHE_CHECK([if gcc/ld supports -Wl,--output-def],
[gl_cv_ld_output_def],
[if test "$enable_shared" = no; then
gl_cv_ld_output_def="not needed, shared libraries are disabled"
else
gl_ldflags_save=$LDFLAGS
LDFLAGS="-Wl,--output-def,conftest.def"
AC_LINK_IFELSE([AC_LANG_PROGRAM([])],
[gl_cv_ld_output_def=yes],
[gl_cv_ld_output_def=no])
rm -f conftest.def
LDFLAGS="$gl_ldflags_save"
fi])
AM_CONDITIONAL([HAVE_LD_OUTPUT_DEF], test "x$gl_cv_ld_output_def" = "xyes")
])
|
281677160/openwrt-package | 3,468 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/m4/ax_check_define.m4 | # ===========================================================================
# http://www.gnu.org/software/autoconf-archive/ax_check_define.html
# ===========================================================================
#
# SYNOPSIS
#
# AC_CHECK_DEFINE([symbol], [ACTION-IF-FOUND], [ACTION-IF-NOT])
# AX_CHECK_DEFINE([includes],[symbol], [ACTION-IF-FOUND], [ACTION-IF-NOT])
#
# DESCRIPTION
#
# Complements AC_CHECK_FUNC but it does not check for a function but for a
# define to exist. Consider a usage like:
#
# AC_CHECK_DEFINE(__STRICT_ANSI__, CFLAGS="$CFLAGS -D_XOPEN_SOURCE=500")
#
# LICENSE
#
# Copyright (c) 2008 Guido U. Draheim <guidod@gmx.de>
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation; either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
# Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
#
# As a special exception, the respective Autoconf Macro's copyright owner
# gives unlimited permission to copy, distribute and modify the configure
# scripts that are the output of Autoconf when processing the Macro. You
# need not follow the terms of the GNU General Public License when using
# or distributing such scripts, even though portions of the text of the
# Macro appear in them. The GNU General Public License (GPL) does govern
# all other use of the material that constitutes the Autoconf Macro.
#
# This special exception to the GPL applies to versions of the Autoconf
# Macro released by the Autoconf Archive. When you make and distribute a
# modified version of the Autoconf Macro, you may extend this special
# exception to the GPL to apply to your modified version as well.
#serial 8
AU_ALIAS([AC_CHECK_DEFINED], [AC_CHECK_DEFINE])
AC_DEFUN([AC_CHECK_DEFINE],[
AS_VAR_PUSHDEF([ac_var],[ac_cv_defined_$1])dnl
AC_CACHE_CHECK([for $1 defined], ac_var,
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
#ifdef $1
int ok;
#else
choke me
#endif
]])],[AS_VAR_SET(ac_var, yes)],[AS_VAR_SET(ac_var, no)]))
AS_IF([test AS_VAR_GET(ac_var) != "no"], [$2], [$3])dnl
AS_VAR_POPDEF([ac_var])dnl
])
AU_ALIAS([AX_CHECK_DEFINED], [AX_CHECK_DEFINE])
AC_DEFUN([AX_CHECK_DEFINE],[
AS_VAR_PUSHDEF([ac_var],[ac_cv_defined_$2_$1])dnl
AC_CACHE_CHECK([for $2 defined in $1], ac_var,
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <$1>]], [[
#ifdef $2
int ok;
#else
choke me
#endif
]])],[AS_VAR_SET(ac_var, yes)],[AS_VAR_SET(ac_var, no)]))
AS_IF([test AS_VAR_GET(ac_var) != "no"], [$3], [$4])dnl
AS_VAR_POPDEF([ac_var])dnl
])
AC_DEFUN([AX_CHECK_FUNC],
[AS_VAR_PUSHDEF([ac_var], [ac_cv_func_$2])dnl
AC_CACHE_CHECK([for $2], ac_var,
dnl AC_LANG_FUNC_LINK_TRY
[AC_LINK_IFELSE([AC_LANG_PROGRAM([$1
#undef $2
char $2 ();],[
char (*f) () = $2;
return f != $2; ])],
[AS_VAR_SET(ac_var, yes)],
[AS_VAR_SET(ac_var, no)])])
AS_IF([test AS_VAR_GET(ac_var) = yes], [$3], [$4])dnl
AS_VAR_POPDEF([ac_var])dnl
])# AC_CHECK_FUNC
|
281677160/openwrt-package | 35,564 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/build-aux/config.sub | #! /bin/sh
# Configuration validation subroutine script.
# Copyright 1992-2013 Free Software Foundation, Inc.
timestamp='2013-08-10'
# This file is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that
# program. This Exception is an additional permission under section 7
# of the GNU General Public License, version 3 ("GPLv3").
# Please send patches with a ChangeLog entry to config-patches@gnu.org.
#
# Configuration subroutine to validate and canonicalize a configuration type.
# Supply the specified configuration type as an argument.
# If it is invalid, we print an error message on stderr and exit with code 1.
# Otherwise, we print the canonical config type on stdout and succeed.
# You can get the latest version of this script from:
# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
# This file is supposed to be the same for all GNU packages
# and recognize all the CPU types, system types and aliases
# that are meaningful with *any* GNU software.
# Each package is responsible for reporting which valid configurations
# it does not support. The user should be able to distinguish
# a failure to support a valid configuration from a meaningless
# configuration.
# The goal of this file is to map all the various variations of a given
# machine specification into a single specification in the form:
# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
# or in some cases, the newer four-part form:
# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
# It is wrong to echo any other type of specification.
me=`echo "$0" | sed -e 's,.*/,,'`
usage="\
Usage: $0 [OPTION] CPU-MFR-OPSYS
$0 [OPTION] ALIAS
Canonicalize a configuration name.
Operation modes:
-h, --help print this help, then exit
-t, --time-stamp print date of last modification, then exit
-v, --version print version number, then exit
Report bugs and patches to <config-patches@gnu.org>."
version="\
GNU config.sub ($timestamp)
Copyright 1992-2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
help="
Try \`$me --help' for more information."
# Parse command line
while test $# -gt 0 ; do
case $1 in
--time-stamp | --time* | -t )
echo "$timestamp" ; exit ;;
--version | -v )
echo "$version" ; exit ;;
--help | --h* | -h )
echo "$usage"; exit ;;
-- ) # Stop option processing
shift; break ;;
- ) # Use stdin as input.
break ;;
-* )
echo "$me: invalid option $1$help"
exit 1 ;;
*local*)
# First pass through any local machine types.
echo $1
exit ;;
* )
break ;;
esac
done
case $# in
0) echo "$me: missing argument$help" >&2
exit 1;;
1) ;;
*) echo "$me: too many arguments$help" >&2
exit 1;;
esac
# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
# Here we must recognize all the valid KERNEL-OS combinations.
maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
case $maybe_os in
nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
knetbsd*-gnu* | netbsd*-gnu* | \
kopensolaris*-gnu* | \
storm-chaos* | os2-emx* | rtmk-nova*)
os=-$maybe_os
basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
;;
android-linux)
os=-linux-android
basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
;;
*)
basic_machine=`echo $1 | sed 's/-[^-]*$//'`
if [ $basic_machine != $1 ]
then os=`echo $1 | sed 's/.*-/-/'`
else os=; fi
;;
esac
### Let's recognize common machines as not being operating systems so
### that things like config.sub decstation-3100 work. We also
### recognize some manufacturers as not being operating systems, so we
### can provide default operating systems below.
case $os in
-sun*os*)
# Prevent following clause from handling this invalid input.
;;
-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
-apple | -axis | -knuth | -cray | -microblaze*)
os=
basic_machine=$1
;;
-bluegene*)
os=-cnk
;;
-sim | -cisco | -oki | -wec | -winbond)
os=
basic_machine=$1
;;
-scout)
;;
-wrs)
os=-vxworks
basic_machine=$1
;;
-chorusos*)
os=-chorusos
basic_machine=$1
;;
-chorusrdb)
os=-chorusrdb
basic_machine=$1
;;
-hiux*)
os=-hiuxwe2
;;
-sco6)
os=-sco5v6
basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
;;
-sco5)
os=-sco3.2v5
basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
;;
-sco4)
os=-sco3.2v4
basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
;;
-sco3.2.[4-9]*)
os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
;;
-sco3.2v[4-9]*)
# Don't forget version if it is 3.2v4 or newer.
basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
;;
-sco5v6*)
# Don't forget version if it is 3.2v4 or newer.
basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
;;
-sco*)
os=-sco3.2v2
basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
;;
-udk*)
basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
;;
-isc)
os=-isc2.2
basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
;;
-clix*)
basic_machine=clipper-intergraph
;;
-isc*)
basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
;;
-lynx*178)
os=-lynxos178
;;
-lynx*5)
os=-lynxos5
;;
-lynx*)
os=-lynxos
;;
-ptx*)
basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
;;
-windowsnt*)
os=`echo $os | sed -e 's/windowsnt/winnt/'`
;;
-psos*)
os=-psos
;;
-mint | -mint[0-9]*)
basic_machine=m68k-atari
os=-mint
;;
esac
# Decode aliases for certain CPU-COMPANY combinations.
case $basic_machine in
# Recognize the basic CPU types without company name.
# Some are omitted here because they have special meanings below.
1750a | 580 \
| a29k \
| aarch64 | aarch64_be \
| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
| am33_2.0 \
| arc | arceb \
| arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \
| avr | avr32 \
| be32 | be64 \
| bfin \
| c4x | c8051 | clipper \
| d10v | d30v | dlx | dsp16xx \
| epiphany \
| fido | fr30 | frv \
| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
| hexagon \
| i370 | i860 | i960 | ia64 \
| ip2k | iq2000 \
| le32 | le64 \
| lm32 \
| m32c | m32r | m32rle | m68000 | m68k | m88k \
| maxq | mb | microblaze | microblazeel | mcore | mep | metag \
| mips | mipsbe | mipseb | mipsel | mipsle \
| mips16 \
| mips64 | mips64el \
| mips64octeon | mips64octeonel \
| mips64orion | mips64orionel \
| mips64r5900 | mips64r5900el \
| mips64vr | mips64vrel \
| mips64vr4100 | mips64vr4100el \
| mips64vr4300 | mips64vr4300el \
| mips64vr5000 | mips64vr5000el \
| mips64vr5900 | mips64vr5900el \
| mipsisa32 | mipsisa32el \
| mipsisa32r2 | mipsisa32r2el \
| mipsisa64 | mipsisa64el \
| mipsisa64r2 | mipsisa64r2el \
| mipsisa64sb1 | mipsisa64sb1el \
| mipsisa64sr71k | mipsisa64sr71kel \
| mipsr5900 | mipsr5900el \
| mipstx39 | mipstx39el \
| mn10200 | mn10300 \
| moxie \
| mt \
| msp430 \
| nds32 | nds32le | nds32be \
| nios | nios2 | nios2eb | nios2el \
| ns16k | ns32k \
| open8 \
| or1k | or32 \
| pdp10 | pdp11 | pj | pjl \
| powerpc | powerpc64 | powerpc64le | powerpcle \
| pyramid \
| rl78 | rx \
| score \
| sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
| sh64 | sh64le \
| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
| sparcv8 | sparcv9 | sparcv9b | sparcv9v \
| spu \
| tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
| ubicom32 \
| v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
| we32k \
| x86 | xc16x | xstormy16 | xtensa \
| z8k | z80)
basic_machine=$basic_machine-unknown
;;
c54x)
basic_machine=tic54x-unknown
;;
c55x)
basic_machine=tic55x-unknown
;;
c6x)
basic_machine=tic6x-unknown
;;
m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | picochip)
basic_machine=$basic_machine-unknown
os=-none
;;
m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
;;
ms1)
basic_machine=mt-unknown
;;
strongarm | thumb | xscale)
basic_machine=arm-unknown
;;
xgate)
basic_machine=$basic_machine-unknown
os=-none
;;
xscaleeb)
basic_machine=armeb-unknown
;;
xscaleel)
basic_machine=armel-unknown
;;
# We use `pc' rather than `unknown'
# because (1) that's what they normally are, and
# (2) the word "unknown" tends to confuse beginning users.
i*86 | x86_64)
basic_machine=$basic_machine-pc
;;
# Object if more than one company name word.
*-*-*)
echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
exit 1
;;
# Recognize the basic CPU types with company name.
580-* \
| a29k-* \
| aarch64-* | aarch64_be-* \
| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
| alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \
| arm-* | armbe-* | armle-* | armeb-* | armv*-* \
| avr-* | avr32-* \
| be32-* | be64-* \
| bfin-* | bs2000-* \
| c[123]* | c30-* | [cjt]90-* | c4x-* \
| c8051-* | clipper-* | craynv-* | cydra-* \
| d10v-* | d30v-* | dlx-* \
| elxsi-* \
| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
| h8300-* | h8500-* \
| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
| hexagon-* \
| i*86-* | i860-* | i960-* | ia64-* \
| ip2k-* | iq2000-* \
| le32-* | le64-* \
| lm32-* \
| m32c-* | m32r-* | m32rle-* \
| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
| m88110-* | m88k-* | maxq-* | mcore-* | metag-* \
| microblaze-* | microblazeel-* \
| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
| mips16-* \
| mips64-* | mips64el-* \
| mips64octeon-* | mips64octeonel-* \
| mips64orion-* | mips64orionel-* \
| mips64r5900-* | mips64r5900el-* \
| mips64vr-* | mips64vrel-* \
| mips64vr4100-* | mips64vr4100el-* \
| mips64vr4300-* | mips64vr4300el-* \
| mips64vr5000-* | mips64vr5000el-* \
| mips64vr5900-* | mips64vr5900el-* \
| mipsisa32-* | mipsisa32el-* \
| mipsisa32r2-* | mipsisa32r2el-* \
| mipsisa64-* | mipsisa64el-* \
| mipsisa64r2-* | mipsisa64r2el-* \
| mipsisa64sb1-* | mipsisa64sb1el-* \
| mipsisa64sr71k-* | mipsisa64sr71kel-* \
| mipsr5900-* | mipsr5900el-* \
| mipstx39-* | mipstx39el-* \
| mmix-* \
| mt-* \
| msp430-* \
| nds32-* | nds32le-* | nds32be-* \
| nios-* | nios2-* | nios2eb-* | nios2el-* \
| none-* | np1-* | ns16k-* | ns32k-* \
| open8-* \
| orion-* \
| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
| pyramid-* \
| rl78-* | romp-* | rs6000-* | rx-* \
| sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
| sparclite-* \
| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \
| tahoe-* \
| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
| tile*-* \
| tron-* \
| ubicom32-* \
| v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
| vax-* \
| we32k-* \
| x86-* | x86_64-* | xc16x-* | xps100-* \
| xstormy16-* | xtensa*-* \
| ymp-* \
| z8k-* | z80-*)
;;
# Recognize the basic CPU types without company name, with glob match.
xtensa*)
basic_machine=$basic_machine-unknown
;;
# Recognize the various machine names and aliases which stand
# for a CPU type and a company and sometimes even an OS.
386bsd)
basic_machine=i386-unknown
os=-bsd
;;
3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
basic_machine=m68000-att
;;
3b*)
basic_machine=we32k-att
;;
a29khif)
basic_machine=a29k-amd
os=-udi
;;
abacus)
basic_machine=abacus-unknown
;;
adobe68k)
basic_machine=m68010-adobe
os=-scout
;;
alliant | fx80)
basic_machine=fx80-alliant
;;
altos | altos3068)
basic_machine=m68k-altos
;;
am29k)
basic_machine=a29k-none
os=-bsd
;;
amd64)
basic_machine=x86_64-pc
;;
amd64-*)
basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
amdahl)
basic_machine=580-amdahl
os=-sysv
;;
amiga | amiga-*)
basic_machine=m68k-unknown
;;
amigaos | amigados)
basic_machine=m68k-unknown
os=-amigaos
;;
amigaunix | amix)
basic_machine=m68k-unknown
os=-sysv4
;;
apollo68)
basic_machine=m68k-apollo
os=-sysv
;;
apollo68bsd)
basic_machine=m68k-apollo
os=-bsd
;;
aros)
basic_machine=i386-pc
os=-aros
;;
aux)
basic_machine=m68k-apple
os=-aux
;;
balance)
basic_machine=ns32k-sequent
os=-dynix
;;
blackfin)
basic_machine=bfin-unknown
os=-linux
;;
blackfin-*)
basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'`
os=-linux
;;
bluegene*)
basic_machine=powerpc-ibm
os=-cnk
;;
c54x-*)
basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
c55x-*)
basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
c6x-*)
basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
c90)
basic_machine=c90-cray
os=-unicos
;;
cegcc)
basic_machine=arm-unknown
os=-cegcc
;;
convex-c1)
basic_machine=c1-convex
os=-bsd
;;
convex-c2)
basic_machine=c2-convex
os=-bsd
;;
convex-c32)
basic_machine=c32-convex
os=-bsd
;;
convex-c34)
basic_machine=c34-convex
os=-bsd
;;
convex-c38)
basic_machine=c38-convex
os=-bsd
;;
cray | j90)
basic_machine=j90-cray
os=-unicos
;;
craynv)
basic_machine=craynv-cray
os=-unicosmp
;;
cr16 | cr16-*)
basic_machine=cr16-unknown
os=-elf
;;
crds | unos)
basic_machine=m68k-crds
;;
crisv32 | crisv32-* | etraxfs*)
basic_machine=crisv32-axis
;;
cris | cris-* | etrax*)
basic_machine=cris-axis
;;
crx)
basic_machine=crx-unknown
os=-elf
;;
da30 | da30-*)
basic_machine=m68k-da30
;;
decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
basic_machine=mips-dec
;;
decsystem10* | dec10*)
basic_machine=pdp10-dec
os=-tops10
;;
decsystem20* | dec20*)
basic_machine=pdp10-dec
os=-tops20
;;
delta | 3300 | motorola-3300 | motorola-delta \
| 3300-motorola | delta-motorola)
basic_machine=m68k-motorola
;;
delta88)
basic_machine=m88k-motorola
os=-sysv3
;;
dicos)
basic_machine=i686-pc
os=-dicos
;;
djgpp)
basic_machine=i586-pc
os=-msdosdjgpp
;;
dpx20 | dpx20-*)
basic_machine=rs6000-bull
os=-bosx
;;
dpx2* | dpx2*-bull)
basic_machine=m68k-bull
os=-sysv3
;;
ebmon29k)
basic_machine=a29k-amd
os=-ebmon
;;
elxsi)
basic_machine=elxsi-elxsi
os=-bsd
;;
encore | umax | mmax)
basic_machine=ns32k-encore
;;
es1800 | OSE68k | ose68k | ose | OSE)
basic_machine=m68k-ericsson
os=-ose
;;
fx2800)
basic_machine=i860-alliant
;;
genix)
basic_machine=ns32k-ns
;;
gmicro)
basic_machine=tron-gmicro
os=-sysv
;;
go32)
basic_machine=i386-pc
os=-go32
;;
h3050r* | hiux*)
basic_machine=hppa1.1-hitachi
os=-hiuxwe2
;;
h8300hms)
basic_machine=h8300-hitachi
os=-hms
;;
h8300xray)
basic_machine=h8300-hitachi
os=-xray
;;
h8500hms)
basic_machine=h8500-hitachi
os=-hms
;;
harris)
basic_machine=m88k-harris
os=-sysv3
;;
hp300-*)
basic_machine=m68k-hp
;;
hp300bsd)
basic_machine=m68k-hp
os=-bsd
;;
hp300hpux)
basic_machine=m68k-hp
os=-hpux
;;
hp3k9[0-9][0-9] | hp9[0-9][0-9])
basic_machine=hppa1.0-hp
;;
hp9k2[0-9][0-9] | hp9k31[0-9])
basic_machine=m68000-hp
;;
hp9k3[2-9][0-9])
basic_machine=m68k-hp
;;
hp9k6[0-9][0-9] | hp6[0-9][0-9])
basic_machine=hppa1.0-hp
;;
hp9k7[0-79][0-9] | hp7[0-79][0-9])
basic_machine=hppa1.1-hp
;;
hp9k78[0-9] | hp78[0-9])
# FIXME: really hppa2.0-hp
basic_machine=hppa1.1-hp
;;
hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
# FIXME: really hppa2.0-hp
basic_machine=hppa1.1-hp
;;
hp9k8[0-9][13679] | hp8[0-9][13679])
basic_machine=hppa1.1-hp
;;
hp9k8[0-9][0-9] | hp8[0-9][0-9])
basic_machine=hppa1.0-hp
;;
hppa-next)
os=-nextstep3
;;
hppaosf)
basic_machine=hppa1.1-hp
os=-osf
;;
hppro)
basic_machine=hppa1.1-hp
os=-proelf
;;
i370-ibm* | ibm*)
basic_machine=i370-ibm
;;
i*86v32)
basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
os=-sysv32
;;
i*86v4*)
basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
os=-sysv4
;;
i*86v)
basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
os=-sysv
;;
i*86sol2)
basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
os=-solaris2
;;
i386mach)
basic_machine=i386-mach
os=-mach
;;
i386-vsta | vsta)
basic_machine=i386-unknown
os=-vsta
;;
iris | iris4d)
basic_machine=mips-sgi
case $os in
-irix*)
;;
*)
os=-irix4
;;
esac
;;
isi68 | isi)
basic_machine=m68k-isi
os=-sysv
;;
m68knommu)
basic_machine=m68k-unknown
os=-linux
;;
m68knommu-*)
basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'`
os=-linux
;;
m88k-omron*)
basic_machine=m88k-omron
;;
magnum | m3230)
basic_machine=mips-mips
os=-sysv
;;
merlin)
basic_machine=ns32k-utek
os=-sysv
;;
microblaze*)
basic_machine=microblaze-xilinx
;;
mingw64)
basic_machine=x86_64-pc
os=-mingw64
;;
mingw32)
basic_machine=i686-pc
os=-mingw32
;;
mingw32ce)
basic_machine=arm-unknown
os=-mingw32ce
;;
miniframe)
basic_machine=m68000-convergent
;;
*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
basic_machine=m68k-atari
os=-mint
;;
mips3*-*)
basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
;;
mips3*)
basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
;;
monitor)
basic_machine=m68k-rom68k
os=-coff
;;
morphos)
basic_machine=powerpc-unknown
os=-morphos
;;
msdos)
basic_machine=i386-pc
os=-msdos
;;
ms1-*)
basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'`
;;
msys)
basic_machine=i686-pc
os=-msys
;;
mvs)
basic_machine=i370-ibm
os=-mvs
;;
nacl)
basic_machine=le32-unknown
os=-nacl
;;
ncr3000)
basic_machine=i486-ncr
os=-sysv4
;;
netbsd386)
basic_machine=i386-unknown
os=-netbsd
;;
netwinder)
basic_machine=armv4l-rebel
os=-linux
;;
news | news700 | news800 | news900)
basic_machine=m68k-sony
os=-newsos
;;
news1000)
basic_machine=m68030-sony
os=-newsos
;;
news-3600 | risc-news)
basic_machine=mips-sony
os=-newsos
;;
necv70)
basic_machine=v70-nec
os=-sysv
;;
next | m*-next )
basic_machine=m68k-next
case $os in
-nextstep* )
;;
-ns2*)
os=-nextstep2
;;
*)
os=-nextstep3
;;
esac
;;
nh3000)
basic_machine=m68k-harris
os=-cxux
;;
nh[45]000)
basic_machine=m88k-harris
os=-cxux
;;
nindy960)
basic_machine=i960-intel
os=-nindy
;;
mon960)
basic_machine=i960-intel
os=-mon960
;;
nonstopux)
basic_machine=mips-compaq
os=-nonstopux
;;
np1)
basic_machine=np1-gould
;;
neo-tandem)
basic_machine=neo-tandem
;;
nse-tandem)
basic_machine=nse-tandem
;;
nsr-tandem)
basic_machine=nsr-tandem
;;
op50n-* | op60c-*)
basic_machine=hppa1.1-oki
os=-proelf
;;
openrisc | openrisc-*)
basic_machine=or32-unknown
;;
os400)
basic_machine=powerpc-ibm
os=-os400
;;
OSE68000 | ose68000)
basic_machine=m68000-ericsson
os=-ose
;;
os68k)
basic_machine=m68k-none
os=-os68k
;;
pa-hitachi)
basic_machine=hppa1.1-hitachi
os=-hiuxwe2
;;
paragon)
basic_machine=i860-intel
os=-osf
;;
parisc)
basic_machine=hppa-unknown
os=-linux
;;
parisc-*)
basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'`
os=-linux
;;
pbd)
basic_machine=sparc-tti
;;
pbb)
basic_machine=m68k-tti
;;
pc532 | pc532-*)
basic_machine=ns32k-pc532
;;
pc98)
basic_machine=i386-pc
;;
pc98-*)
basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
pentium | p5 | k5 | k6 | nexgen | viac3)
basic_machine=i586-pc
;;
pentiumpro | p6 | 6x86 | athlon | athlon_*)
basic_machine=i686-pc
;;
pentiumii | pentium2 | pentiumiii | pentium3)
basic_machine=i686-pc
;;
pentium4)
basic_machine=i786-pc
;;
pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
pentiumpro-* | p6-* | 6x86-* | athlon-*)
basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
pentium4-*)
basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
pn)
basic_machine=pn-gould
;;
power) basic_machine=power-ibm
;;
ppc | ppcbe) basic_machine=powerpc-unknown
;;
ppc-* | ppcbe-*)
basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
ppcle | powerpclittle | ppc-le | powerpc-little)
basic_machine=powerpcle-unknown
;;
ppcle-* | powerpclittle-*)
basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
ppc64) basic_machine=powerpc64-unknown
;;
ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
ppc64le | powerpc64little | ppc64-le | powerpc64-little)
basic_machine=powerpc64le-unknown
;;
ppc64le-* | powerpc64little-*)
basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
ps2)
basic_machine=i386-ibm
;;
pw32)
basic_machine=i586-unknown
os=-pw32
;;
rdos | rdos64)
basic_machine=x86_64-pc
os=-rdos
;;
rdos32)
basic_machine=i386-pc
os=-rdos
;;
rom68k)
basic_machine=m68k-rom68k
os=-coff
;;
rm[46]00)
basic_machine=mips-siemens
;;
rtpc | rtpc-*)
basic_machine=romp-ibm
;;
s390 | s390-*)
basic_machine=s390-ibm
;;
s390x | s390x-*)
basic_machine=s390x-ibm
;;
sa29200)
basic_machine=a29k-amd
os=-udi
;;
sb1)
basic_machine=mipsisa64sb1-unknown
;;
sb1el)
basic_machine=mipsisa64sb1el-unknown
;;
sde)
basic_machine=mipsisa32-sde
os=-elf
;;
sei)
basic_machine=mips-sei
os=-seiux
;;
sequent)
basic_machine=i386-sequent
;;
sh)
basic_machine=sh-hitachi
os=-hms
;;
sh5el)
basic_machine=sh5le-unknown
;;
sh64)
basic_machine=sh64-unknown
;;
sparclite-wrs | simso-wrs)
basic_machine=sparclite-wrs
os=-vxworks
;;
sps7)
basic_machine=m68k-bull
os=-sysv2
;;
spur)
basic_machine=spur-unknown
;;
st2000)
basic_machine=m68k-tandem
;;
stratus)
basic_machine=i860-stratus
os=-sysv4
;;
strongarm-* | thumb-*)
basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
sun2)
basic_machine=m68000-sun
;;
sun2os3)
basic_machine=m68000-sun
os=-sunos3
;;
sun2os4)
basic_machine=m68000-sun
os=-sunos4
;;
sun3os3)
basic_machine=m68k-sun
os=-sunos3
;;
sun3os4)
basic_machine=m68k-sun
os=-sunos4
;;
sun4os3)
basic_machine=sparc-sun
os=-sunos3
;;
sun4os4)
basic_machine=sparc-sun
os=-sunos4
;;
sun4sol2)
basic_machine=sparc-sun
os=-solaris2
;;
sun3 | sun3-*)
basic_machine=m68k-sun
;;
sun4)
basic_machine=sparc-sun
;;
sun386 | sun386i | roadrunner)
basic_machine=i386-sun
;;
sv1)
basic_machine=sv1-cray
os=-unicos
;;
symmetry)
basic_machine=i386-sequent
os=-dynix
;;
t3e)
basic_machine=alphaev5-cray
os=-unicos
;;
t90)
basic_machine=t90-cray
os=-unicos
;;
tile*)
basic_machine=$basic_machine-unknown
os=-linux-gnu
;;
tx39)
basic_machine=mipstx39-unknown
;;
tx39el)
basic_machine=mipstx39el-unknown
;;
toad1)
basic_machine=pdp10-xkl
os=-tops20
;;
tower | tower-32)
basic_machine=m68k-ncr
;;
tpf)
basic_machine=s390x-ibm
os=-tpf
;;
udi29k)
basic_machine=a29k-amd
os=-udi
;;
ultra3)
basic_machine=a29k-nyu
os=-sym1
;;
v810 | necv810)
basic_machine=v810-nec
os=-none
;;
vaxv)
basic_machine=vax-dec
os=-sysv
;;
vms)
basic_machine=vax-dec
os=-vms
;;
vpp*|vx|vx-*)
basic_machine=f301-fujitsu
;;
vxworks960)
basic_machine=i960-wrs
os=-vxworks
;;
vxworks68)
basic_machine=m68k-wrs
os=-vxworks
;;
vxworks29k)
basic_machine=a29k-wrs
os=-vxworks
;;
w65*)
basic_machine=w65-wdc
os=-none
;;
w89k-*)
basic_machine=hppa1.1-winbond
os=-proelf
;;
xbox)
basic_machine=i686-pc
os=-mingw32
;;
xps | xps100)
basic_machine=xps100-honeywell
;;
xscale-* | xscalee[bl]-*)
basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'`
;;
ymp)
basic_machine=ymp-cray
os=-unicos
;;
z8k-*-coff)
basic_machine=z8k-unknown
os=-sim
;;
z80-*-coff)
basic_machine=z80-unknown
os=-sim
;;
none)
basic_machine=none-none
os=-none
;;
# Here we handle the default manufacturer of certain CPU types. It is in
# some cases the only manufacturer, in others, it is the most popular.
w89k)
basic_machine=hppa1.1-winbond
;;
op50n)
basic_machine=hppa1.1-oki
;;
op60c)
basic_machine=hppa1.1-oki
;;
romp)
basic_machine=romp-ibm
;;
mmix)
basic_machine=mmix-knuth
;;
rs6000)
basic_machine=rs6000-ibm
;;
vax)
basic_machine=vax-dec
;;
pdp10)
# there are many clones, so DEC is not a safe bet
basic_machine=pdp10-unknown
;;
pdp11)
basic_machine=pdp11-dec
;;
we32k)
basic_machine=we32k-att
;;
sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
basic_machine=sh-unknown
;;
sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)
basic_machine=sparc-sun
;;
cydra)
basic_machine=cydra-cydrome
;;
orion)
basic_machine=orion-highlevel
;;
orion105)
basic_machine=clipper-highlevel
;;
mac | mpw | mac-mpw)
basic_machine=m68k-apple
;;
pmac | pmac-mpw)
basic_machine=powerpc-apple
;;
*-unknown)
# Make sure to match an already-canonicalized machine name.
;;
*)
echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
exit 1
;;
esac
# Here we canonicalize certain aliases for manufacturers.
case $basic_machine in
*-digital*)
basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
;;
*-commodore*)
basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
;;
*)
;;
esac
# Decode manufacturer-specific aliases for certain operating systems.
if [ x"$os" != x"" ]
then
case $os in
# First match some system type aliases
# that might get confused with valid system types.
# -solaris* is a basic system type, with this one exception.
-auroraux)
os=-auroraux
;;
-solaris1 | -solaris1.*)
os=`echo $os | sed -e 's|solaris1|sunos4|'`
;;
-solaris)
os=-solaris2
;;
-svr4*)
os=-sysv4
;;
-unixware*)
os=-sysv4.2uw
;;
-gnu/linux*)
os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
;;
# First accept the basic system types.
# The portable systems comes first.
# Each alternative MUST END IN A *, to match a version number.
# -sysv* is not here because it comes later, after sysvr4.
-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
| -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
| -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
| -sym* | -kopensolaris* | -plan9* \
| -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
| -aos* | -aros* \
| -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
| -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
| -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
| -bitrig* | -openbsd* | -solidbsd* \
| -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
| -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
| -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
| -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
| -chorusos* | -chorusrdb* | -cegcc* \
| -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
| -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
| -linux-newlib* | -linux-musl* | -linux-uclibc* \
| -uxpv* | -beos* | -mpeix* | -udk* \
| -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
| -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
| -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
| -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
| -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
| -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
| -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*)
# Remember, each alternative MUST END IN *, to match a version number.
;;
-qnx*)
case $basic_machine in
x86-* | i*86-*)
;;
*)
os=-nto$os
;;
esac
;;
-nto-qnx*)
;;
-nto*)
os=`echo $os | sed -e 's|nto|nto-qnx|'`
;;
-sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
| -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \
| -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
;;
-mac*)
os=`echo $os | sed -e 's|mac|macos|'`
;;
-linux-dietlibc)
os=-linux-dietlibc
;;
-linux*)
os=`echo $os | sed -e 's|linux|linux-gnu|'`
;;
-sunos5*)
os=`echo $os | sed -e 's|sunos5|solaris2|'`
;;
-sunos6*)
os=`echo $os | sed -e 's|sunos6|solaris3|'`
;;
-opened*)
os=-openedition
;;
-os400*)
os=-os400
;;
-wince*)
os=-wince
;;
-osfrose*)
os=-osfrose
;;
-osf*)
os=-osf
;;
-utek*)
os=-bsd
;;
-dynix*)
os=-bsd
;;
-acis*)
os=-aos
;;
-atheos*)
os=-atheos
;;
-syllable*)
os=-syllable
;;
-386bsd)
os=-bsd
;;
-ctix* | -uts*)
os=-sysv
;;
-nova*)
os=-rtmk-nova
;;
-ns2 )
os=-nextstep2
;;
-nsk*)
os=-nsk
;;
# Preserve the version number of sinix5.
-sinix5.*)
os=`echo $os | sed -e 's|sinix|sysv|'`
;;
-sinix*)
os=-sysv4
;;
-tpf*)
os=-tpf
;;
-triton*)
os=-sysv3
;;
-oss*)
os=-sysv3
;;
-svr4)
os=-sysv4
;;
-svr3)
os=-sysv3
;;
-sysvr4)
os=-sysv4
;;
# This must come after -sysvr4.
-sysv*)
;;
-ose*)
os=-ose
;;
-es1800*)
os=-ose
;;
-xenix)
os=-xenix
;;
-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
os=-mint
;;
-aros*)
os=-aros
;;
-zvmoe)
os=-zvmoe
;;
-dicos*)
os=-dicos
;;
-nacl*)
;;
-none)
;;
*)
# Get rid of the `-' at the beginning of $os.
os=`echo $os | sed 's/[^-]*-//'`
echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
exit 1
;;
esac
else
# Here we handle the default operating systems that come with various machines.
# The value should be what the vendor currently ships out the door with their
# machine or put another way, the most popular os provided with the machine.
# Note that if you're going to try to match "-MANUFACTURER" here (say,
# "-sun"), then you have to tell the case statement up towards the top
# that MANUFACTURER isn't an operating system. Otherwise, code above
# will signal an error saying that MANUFACTURER isn't an operating
# system, and we'll never get to this point.
case $basic_machine in
score-*)
os=-elf
;;
spu-*)
os=-elf
;;
*-acorn)
os=-riscix1.2
;;
arm*-rebel)
os=-linux
;;
arm*-semi)
os=-aout
;;
c4x-* | tic4x-*)
os=-coff
;;
c8051-*)
os=-elf
;;
hexagon-*)
os=-elf
;;
tic54x-*)
os=-coff
;;
tic55x-*)
os=-coff
;;
tic6x-*)
os=-coff
;;
# This must come before the *-dec entry.
pdp10-*)
os=-tops20
;;
pdp11-*)
os=-none
;;
*-dec | vax-*)
os=-ultrix4.2
;;
m68*-apollo)
os=-domain
;;
i386-sun)
os=-sunos4.0.2
;;
m68000-sun)
os=-sunos3
;;
m68*-cisco)
os=-aout
;;
mep-*)
os=-elf
;;
mips*-cisco)
os=-elf
;;
mips*-*)
os=-elf
;;
or1k-*)
os=-elf
;;
or32-*)
os=-coff
;;
*-tti) # must be before sparc entry or we get the wrong os.
os=-sysv3
;;
sparc-* | *-sun)
os=-sunos4.1.1
;;
*-be)
os=-beos
;;
*-haiku)
os=-haiku
;;
*-ibm)
os=-aix
;;
*-knuth)
os=-mmixware
;;
*-wec)
os=-proelf
;;
*-winbond)
os=-proelf
;;
*-oki)
os=-proelf
;;
*-hp)
os=-hpux
;;
*-hitachi)
os=-hiux
;;
i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
os=-sysv
;;
*-cbm)
os=-amigaos
;;
*-dg)
os=-dgux
;;
*-dolphin)
os=-sysv3
;;
m68k-ccur)
os=-rtu
;;
m88k-omron*)
os=-luna
;;
*-next )
os=-nextstep
;;
*-sequent)
os=-ptx
;;
*-crds)
os=-unos
;;
*-ns)
os=-genix
;;
i370-*)
os=-mvs
;;
*-next)
os=-nextstep3
;;
*-gould)
os=-sysv
;;
*-highlevel)
os=-bsd
;;
*-encore)
os=-bsd
;;
*-sgi)
os=-irix
;;
*-siemens)
os=-sysv4
;;
*-masscomp)
os=-rtu
;;
f30[01]-fujitsu | f700-fujitsu)
os=-uxpv
;;
*-rom68k)
os=-coff
;;
*-*bug)
os=-coff
;;
*-apple)
os=-macos
;;
*-atari*)
os=-mint
;;
*)
os=-none
;;
esac
fi
# Here we handle the case where we know the os, and the CPU type, but not the
# manufacturer. We pick the logical manufacturer.
vendor=unknown
case $basic_machine in
*-unknown)
case $os in
-riscix*)
vendor=acorn
;;
-sunos*)
vendor=sun
;;
-cnk*|-aix*)
vendor=ibm
;;
-beos*)
vendor=be
;;
-hpux*)
vendor=hp
;;
-mpeix*)
vendor=hp
;;
-hiux*)
vendor=hitachi
;;
-unos*)
vendor=crds
;;
-dgux*)
vendor=dg
;;
-luna*)
vendor=omron
;;
-genix*)
vendor=ns
;;
-mvs* | -opened*)
vendor=ibm
;;
-os400*)
vendor=ibm
;;
-ptx*)
vendor=sequent
;;
-tpf*)
vendor=ibm
;;
-vxsim* | -vxworks* | -windiss*)
vendor=wrs
;;
-aux*)
vendor=apple
;;
-hms*)
vendor=hitachi
;;
-mpw* | -macos*)
vendor=apple
;;
-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
vendor=atari
;;
-vos*)
vendor=stratus
;;
esac
basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
;;
esac
echo $basic_machine$os
exit
# Local variables:
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "timestamp='"
# time-stamp-format: "%:y-%02m-%02d"
# time-stamp-end: "'"
# End:
|
281677160/openwrt-package | 13,997 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/build-aux/install-sh | #!/bin/sh
# install - install a program, script, or datafile
scriptversion=2011-11-20.07; # UTC
# This originates from X11R5 (mit/util/scripts/install.sh), which was
# later released in X11R6 (xc/config/util/install.sh) with the
# following copyright and license.
#
# Copyright (C) 1994 X Consortium
#
# 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
# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
# Except as contained in this notice, the name of the X Consortium shall not
# be used in advertising or otherwise to promote the sale, use or other deal-
# ings in this Software without prior written authorization from the X Consor-
# tium.
#
#
# FSF changes to this file are in the public domain.
#
# Calling this script install-sh is preferred over install.sh, to prevent
# 'make' implicit rules from creating a file called install from it
# when there is no Makefile.
#
# This script is compatible with the BSD install script, but was written
# from scratch.
nl='
'
IFS=" "" $nl"
# set DOITPROG to echo to test this script
# Don't use :- since 4.3BSD and earlier shells don't like it.
doit=${DOITPROG-}
if test -z "$doit"; then
doit_exec=exec
else
doit_exec=$doit
fi
# Put in absolute file names if you don't have them in your path;
# or use environment vars.
chgrpprog=${CHGRPPROG-chgrp}
chmodprog=${CHMODPROG-chmod}
chownprog=${CHOWNPROG-chown}
cmpprog=${CMPPROG-cmp}
cpprog=${CPPROG-cp}
mkdirprog=${MKDIRPROG-mkdir}
mvprog=${MVPROG-mv}
rmprog=${RMPROG-rm}
stripprog=${STRIPPROG-strip}
posix_glob='?'
initialize_posix_glob='
test "$posix_glob" != "?" || {
if (set -f) 2>/dev/null; then
posix_glob=
else
posix_glob=:
fi
}
'
posix_mkdir=
# Desired mode of installed file.
mode=0755
chgrpcmd=
chmodcmd=$chmodprog
chowncmd=
mvcmd=$mvprog
rmcmd="$rmprog -f"
stripcmd=
src=
dst=
dir_arg=
dst_arg=
copy_on_change=false
no_target_directory=
usage="\
Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
or: $0 [OPTION]... SRCFILES... DIRECTORY
or: $0 [OPTION]... -t DIRECTORY SRCFILES...
or: $0 [OPTION]... -d DIRECTORIES...
In the 1st form, copy SRCFILE to DSTFILE.
In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
In the 4th, create DIRECTORIES.
Options:
--help display this help and exit.
--version display version info and exit.
-c (ignored)
-C install only if different (preserve the last data modification time)
-d create directories instead of installing files.
-g GROUP $chgrpprog installed files to GROUP.
-m MODE $chmodprog installed files to MODE.
-o USER $chownprog installed files to USER.
-s $stripprog installed files.
-t DIRECTORY install into DIRECTORY.
-T report an error if DSTFILE is a directory.
Environment variables override the default commands:
CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
RMPROG STRIPPROG
"
while test $# -ne 0; do
case $1 in
-c) ;;
-C) copy_on_change=true;;
-d) dir_arg=true;;
-g) chgrpcmd="$chgrpprog $2"
shift;;
--help) echo "$usage"; exit $?;;
-m) mode=$2
case $mode in
*' '* | *' '* | *'
'* | *'*'* | *'?'* | *'['*)
echo "$0: invalid mode: $mode" >&2
exit 1;;
esac
shift;;
-o) chowncmd="$chownprog $2"
shift;;
-s) stripcmd=$stripprog;;
-t) dst_arg=$2
# Protect names problematic for 'test' and other utilities.
case $dst_arg in
-* | [=\(\)!]) dst_arg=./$dst_arg;;
esac
shift;;
-T) no_target_directory=true;;
--version) echo "$0 $scriptversion"; exit $?;;
--) shift
break;;
-*) echo "$0: invalid option: $1" >&2
exit 1;;
*) break;;
esac
shift
done
if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
# When -d is used, all remaining arguments are directories to create.
# When -t is used, the destination is already specified.
# Otherwise, the last argument is the destination. Remove it from $@.
for arg
do
if test -n "$dst_arg"; then
# $@ is not empty: it contains at least $arg.
set fnord "$@" "$dst_arg"
shift # fnord
fi
shift # arg
dst_arg=$arg
# Protect names problematic for 'test' and other utilities.
case $dst_arg in
-* | [=\(\)!]) dst_arg=./$dst_arg;;
esac
done
fi
if test $# -eq 0; then
if test -z "$dir_arg"; then
echo "$0: no input file specified." >&2
exit 1
fi
# It's OK to call 'install-sh -d' without argument.
# This can happen when creating conditional directories.
exit 0
fi
if test -z "$dir_arg"; then
do_exit='(exit $ret); exit $ret'
trap "ret=129; $do_exit" 1
trap "ret=130; $do_exit" 2
trap "ret=141; $do_exit" 13
trap "ret=143; $do_exit" 15
# Set umask so as not to create temps with too-generous modes.
# However, 'strip' requires both read and write access to temps.
case $mode in
# Optimize common cases.
*644) cp_umask=133;;
*755) cp_umask=22;;
*[0-7])
if test -z "$stripcmd"; then
u_plus_rw=
else
u_plus_rw='% 200'
fi
cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
*)
if test -z "$stripcmd"; then
u_plus_rw=
else
u_plus_rw=,u+rw
fi
cp_umask=$mode$u_plus_rw;;
esac
fi
for src
do
# Protect names problematic for 'test' and other utilities.
case $src in
-* | [=\(\)!]) src=./$src;;
esac
if test -n "$dir_arg"; then
dst=$src
dstdir=$dst
test -d "$dstdir"
dstdir_status=$?
else
# Waiting for this to be detected by the "$cpprog $src $dsttmp" command
# might cause directories to be created, which would be especially bad
# if $src (and thus $dsttmp) contains '*'.
if test ! -f "$src" && test ! -d "$src"; then
echo "$0: $src does not exist." >&2
exit 1
fi
if test -z "$dst_arg"; then
echo "$0: no destination specified." >&2
exit 1
fi
dst=$dst_arg
# If destination is a directory, append the input filename; won't work
# if double slashes aren't ignored.
if test -d "$dst"; then
if test -n "$no_target_directory"; then
echo "$0: $dst_arg: Is a directory" >&2
exit 1
fi
dstdir=$dst
dst=$dstdir/`basename "$src"`
dstdir_status=0
else
# Prefer dirname, but fall back on a substitute if dirname fails.
dstdir=`
(dirname "$dst") 2>/dev/null ||
expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
X"$dst" : 'X\(//\)[^/]' \| \
X"$dst" : 'X\(//\)$' \| \
X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
echo X"$dst" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
}
/^X\(\/\/\)[^/].*/{
s//\1/
q
}
/^X\(\/\/\)$/{
s//\1/
q
}
/^X\(\/\).*/{
s//\1/
q
}
s/.*/./; q'
`
test -d "$dstdir"
dstdir_status=$?
fi
fi
obsolete_mkdir_used=false
if test $dstdir_status != 0; then
case $posix_mkdir in
'')
# Create intermediate dirs using mode 755 as modified by the umask.
# This is like FreeBSD 'install' as of 1997-10-28.
umask=`umask`
case $stripcmd.$umask in
# Optimize common cases.
*[2367][2367]) mkdir_umask=$umask;;
.*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
*[0-7])
mkdir_umask=`expr $umask + 22 \
- $umask % 100 % 40 + $umask % 20 \
- $umask % 10 % 4 + $umask % 2
`;;
*) mkdir_umask=$umask,go-w;;
esac
# With -d, create the new directory with the user-specified mode.
# Otherwise, rely on $mkdir_umask.
if test -n "$dir_arg"; then
mkdir_mode=-m$mode
else
mkdir_mode=
fi
posix_mkdir=false
case $umask in
*[123567][0-7][0-7])
# POSIX mkdir -p sets u+wx bits regardless of umask, which
# is incompatible with FreeBSD 'install' when (umask & 300) != 0.
;;
*)
tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
if (umask $mkdir_umask &&
exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
then
if test -z "$dir_arg" || {
# Check for POSIX incompatibilities with -m.
# HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
# other-writable bit of parent directory when it shouldn't.
# FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
ls_ld_tmpdir=`ls -ld "$tmpdir"`
case $ls_ld_tmpdir in
d????-?r-*) different_mode=700;;
d????-?--*) different_mode=755;;
*) false;;
esac &&
$mkdirprog -m$different_mode -p -- "$tmpdir" && {
ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
}
}
then posix_mkdir=:
fi
rmdir "$tmpdir/d" "$tmpdir"
else
# Remove any dirs left behind by ancient mkdir implementations.
rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
fi
trap '' 0;;
esac;;
esac
if
$posix_mkdir && (
umask $mkdir_umask &&
$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
)
then :
else
# The umask is ridiculous, or mkdir does not conform to POSIX,
# or it failed possibly due to a race condition. Create the
# directory the slow way, step by step, checking for races as we go.
case $dstdir in
/*) prefix='/';;
[-=\(\)!]*) prefix='./';;
*) prefix='';;
esac
eval "$initialize_posix_glob"
oIFS=$IFS
IFS=/
$posix_glob set -f
set fnord $dstdir
shift
$posix_glob set +f
IFS=$oIFS
prefixes=
for d
do
test X"$d" = X && continue
prefix=$prefix$d
if test -d "$prefix"; then
prefixes=
else
if $posix_mkdir; then
(umask=$mkdir_umask &&
$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
# Don't fail if two instances are running concurrently.
test -d "$prefix" || exit 1
else
case $prefix in
*\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
*) qprefix=$prefix;;
esac
prefixes="$prefixes '$qprefix'"
fi
fi
prefix=$prefix/
done
if test -n "$prefixes"; then
# Don't fail if two instances are running concurrently.
(umask $mkdir_umask &&
eval "\$doit_exec \$mkdirprog $prefixes") ||
test -d "$dstdir" || exit 1
obsolete_mkdir_used=true
fi
fi
fi
if test -n "$dir_arg"; then
{ test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
{ test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
{ test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
else
# Make a couple of temp file names in the proper directory.
dsttmp=$dstdir/_inst.$$_
rmtmp=$dstdir/_rm.$$_
# Trap to clean up those temp files at exit.
trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
# Copy the file name to the temp name.
(umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
# and set any options; do chmod last to preserve setuid bits.
#
# If any of these fail, we abort the whole thing. If we want to
# ignore errors from any of these, just make sure not to ignore
# errors from the above "$doit $cpprog $src $dsttmp" command.
#
{ test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
{ test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
{ test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
{ test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
# If -C, don't bother to copy if it wouldn't change the file.
if $copy_on_change &&
old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` &&
new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` &&
eval "$initialize_posix_glob" &&
$posix_glob set -f &&
set X $old && old=:$2:$4:$5:$6 &&
set X $new && new=:$2:$4:$5:$6 &&
$posix_glob set +f &&
test "$old" = "$new" &&
$cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
then
rm -f "$dsttmp"
else
# Rename the file to the real destination.
$doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
# The rename failed, perhaps because mv can't rename something else
# to itself, or perhaps because mv is so ancient that it does not
# support -f.
{
# Now remove or move aside any old file at destination location.
# We try this two ways since rm can't unlink itself on some
# systems and the destination file might be busy for other
# reasons. In this case, the final cleanup might fail but the new
# file should still install successfully.
{
test ! -f "$dst" ||
$doit $rmcmd -f "$dst" 2>/dev/null ||
{ $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
{ $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
} ||
{ echo "$0: cannot unlink or rename $dst" >&2
(exit 1); exit 1
}
} &&
# Now rename the file to the real destination.
$doit $mvcmd "$dsttmp" "$dst"
}
fi || exit 1
trap '' 0
fi
done
# Local variables:
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC"
# time-stamp-end: "; # UTC"
# End:
|
281677160/openwrt-package | 6,872 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/build-aux/missing | #! /bin/sh
# Common wrapper for a few potentially missing GNU programs.
scriptversion=2013-10-28.13; # UTC
# Copyright (C) 1996-2013 Free Software Foundation, Inc.
# Originally written by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
if test $# -eq 0; then
echo 1>&2 "Try '$0 --help' for more information"
exit 1
fi
case $1 in
--is-lightweight)
# Used by our autoconf macros to check whether the available missing
# script is modern enough.
exit 0
;;
--run)
# Back-compat with the calling convention used by older automake.
shift
;;
-h|--h|--he|--hel|--help)
echo "\
$0 [OPTION]... PROGRAM [ARGUMENT]...
Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due
to PROGRAM being missing or too old.
Options:
-h, --help display this help and exit
-v, --version output version information and exit
Supported PROGRAM values:
aclocal autoconf autoheader autom4te automake makeinfo
bison yacc flex lex help2man
Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and
'g' are ignored when checking the name.
Send bug reports to <bug-automake@gnu.org>."
exit $?
;;
-v|--v|--ve|--ver|--vers|--versi|--versio|--version)
echo "missing $scriptversion (GNU Automake)"
exit $?
;;
-*)
echo 1>&2 "$0: unknown '$1' option"
echo 1>&2 "Try '$0 --help' for more information"
exit 1
;;
esac
# Run the given program, remember its exit status.
"$@"; st=$?
# If it succeeded, we are done.
test $st -eq 0 && exit 0
# Also exit now if we it failed (or wasn't found), and '--version' was
# passed; such an option is passed most likely to detect whether the
# program is present and works.
case $2 in --version|--help) exit $st;; esac
# Exit code 63 means version mismatch. This often happens when the user
# tries to use an ancient version of a tool on a file that requires a
# minimum version.
if test $st -eq 63; then
msg="probably too old"
elif test $st -eq 127; then
# Program was missing.
msg="missing on your system"
else
# Program was found and executed, but failed. Give up.
exit $st
fi
perl_URL=http://www.perl.org/
flex_URL=http://flex.sourceforge.net/
gnu_software_URL=http://www.gnu.org/software
program_details ()
{
case $1 in
aclocal|automake)
echo "The '$1' program is part of the GNU Automake package:"
echo "<$gnu_software_URL/automake>"
echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:"
echo "<$gnu_software_URL/autoconf>"
echo "<$gnu_software_URL/m4/>"
echo "<$perl_URL>"
;;
autoconf|autom4te|autoheader)
echo "The '$1' program is part of the GNU Autoconf package:"
echo "<$gnu_software_URL/autoconf/>"
echo "It also requires GNU m4 and Perl in order to run:"
echo "<$gnu_software_URL/m4/>"
echo "<$perl_URL>"
;;
esac
}
give_advice ()
{
# Normalize program name to check for.
normalized_program=`echo "$1" | sed '
s/^gnu-//; t
s/^gnu//; t
s/^g//; t'`
printf '%s\n' "'$1' is $msg."
configure_deps="'configure.ac' or m4 files included by 'configure.ac'"
case $normalized_program in
autoconf*)
echo "You should only need it if you modified 'configure.ac',"
echo "or m4 files included by it."
program_details 'autoconf'
;;
autoheader*)
echo "You should only need it if you modified 'acconfig.h' or"
echo "$configure_deps."
program_details 'autoheader'
;;
automake*)
echo "You should only need it if you modified 'Makefile.am' or"
echo "$configure_deps."
program_details 'automake'
;;
aclocal*)
echo "You should only need it if you modified 'acinclude.m4' or"
echo "$configure_deps."
program_details 'aclocal'
;;
autom4te*)
echo "You might have modified some maintainer files that require"
echo "the 'autom4te' program to be rebuilt."
program_details 'autom4te'
;;
bison*|yacc*)
echo "You should only need it if you modified a '.y' file."
echo "You may want to install the GNU Bison package:"
echo "<$gnu_software_URL/bison/>"
;;
lex*|flex*)
echo "You should only need it if you modified a '.l' file."
echo "You may want to install the Fast Lexical Analyzer package:"
echo "<$flex_URL>"
;;
help2man*)
echo "You should only need it if you modified a dependency" \
"of a man page."
echo "You may want to install the GNU Help2man package:"
echo "<$gnu_software_URL/help2man/>"
;;
makeinfo*)
echo "You should only need it if you modified a '.texi' file, or"
echo "any other file indirectly affecting the aspect of the manual."
echo "You might want to install the Texinfo package:"
echo "<$gnu_software_URL/texinfo/>"
echo "The spurious makeinfo call might also be the consequence of"
echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might"
echo "want to install GNU make:"
echo "<$gnu_software_URL/make/>"
;;
*)
echo "You might have modified some files without having the proper"
echo "tools for further handling them. Check the 'README' file, it"
echo "often tells you about the needed prerequisites for installing"
echo "this package. You may also peek at any GNU archive site, in"
echo "case some other package contains this missing '$1' program."
;;
esac
}
give_advice "$1" | sed -e '1s/^/WARNING: /' \
-e '2,$s/^/ /' >&2
# Propagate the correct exit status (expected to be 127 for a program
# not found, 63 for a program that failed due to version mismatch).
exit $st
# Local variables:
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC"
# time-stamp-end: "; # UTC"
# End:
|
281677160/openwrt-package | 283,684 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/build-aux/ltmain.sh |
# libtool (GNU libtool) 2.4.2
# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
# This is free software; see the source for copying conditions. There is NO
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# GNU Libtool is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# As a special exception to the GNU General Public License,
# if you distribute this file as part of a program or library that
# is built using GNU Libtool, you may include this file under the
# same distribution terms that you use for the rest of that program.
#
# GNU Libtool is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Libtool; see the file COPYING. If not, a copy
# can be downloaded from http://www.gnu.org/licenses/gpl.html,
# or obtained by writing to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
# Usage: $progname [OPTION]... [MODE-ARG]...
#
# Provide generalized library-building support services.
#
# --config show all configuration variables
# --debug enable verbose shell tracing
# -n, --dry-run display commands without modifying any files
# --features display basic configuration information and exit
# --mode=MODE use operation mode MODE
# --preserve-dup-deps don't remove duplicate dependency libraries
# --quiet, --silent don't print informational messages
# --no-quiet, --no-silent
# print informational messages (default)
# --no-warn don't display warning messages
# --tag=TAG use configuration variables from tag TAG
# -v, --verbose print more informational messages than default
# --no-verbose don't print the extra informational messages
# --version print version information
# -h, --help, --help-all print short, long, or detailed help message
#
# MODE must be one of the following:
#
# clean remove files from the build directory
# compile compile a source file into a libtool object
# execute automatically set library path, then run a program
# finish complete the installation of libtool libraries
# install install libraries or executables
# link create a library or an executable
# uninstall remove libraries from an installed directory
#
# MODE-ARGS vary depending on the MODE. When passed as first option,
# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
#
# When reporting a bug, please describe a test case to reproduce it and
# include the following information:
#
# host-triplet: $host
# shell: $SHELL
# compiler: $LTCC
# compiler flags: $LTCFLAGS
# linker: $LD (gnu? $with_gnu_ld)
# $progname: (GNU libtool) 2.4.2 Debian-2.4.2-1.7ubuntu1
# automake: $automake_version
# autoconf: $autoconf_version
#
# Report bugs to <bug-libtool@gnu.org>.
# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
# General help using GNU software: <http://www.gnu.org/gethelp/>.
PROGRAM=libtool
PACKAGE=libtool
VERSION="2.4.2 Debian-2.4.2-1.7ubuntu1"
TIMESTAMP=""
package_revision=1.3337
# Be Bourne compatible
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
emulate sh
NULLCMD=:
# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
# is contrary to our usage. Disable this feature.
alias -g '${1+"$@"}'='"$@"'
setopt NO_GLOB_SUBST
else
case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
fi
BIN_SH=xpg4; export BIN_SH # for Tru64
DUALCASE=1; export DUALCASE # for MKS sh
# A function that is used when there is no print builtin or printf.
func_fallback_echo ()
{
eval 'cat <<_LTECHO_EOF
$1
_LTECHO_EOF'
}
# NLS nuisances: We save the old values to restore during execute mode.
lt_user_locale=
lt_safe_locale=
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
do
eval "if test \"\${$lt_var+set}\" = set; then
save_$lt_var=\$$lt_var
$lt_var=C
export $lt_var
lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
fi"
done
LC_ALL=C
LANGUAGE=C
export LANGUAGE LC_ALL
$lt_unset CDPATH
# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
# is ksh but when the shell is invoked as "sh" and the current value of
# the _XPG environment variable is not equal to 1 (one), the special
# positional parameter $0, within a function call, is the name of the
# function.
progpath="$0"
: ${CP="cp -f"}
test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
: ${MAKE="make"}
: ${MKDIR="mkdir"}
: ${MV="mv -f"}
: ${RM="rm -f"}
: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
: ${Xsed="$SED -e 1s/^X//"}
# Global variables:
EXIT_SUCCESS=0
EXIT_FAILURE=1
EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
exit_status=$EXIT_SUCCESS
# Make sure IFS has a sensible default
lt_nl='
'
IFS=" $lt_nl"
dirname="s,/[^/]*$,,"
basename="s,^.*/,,"
# func_dirname file append nondir_replacement
# Compute the dirname of FILE. If nonempty, add APPEND to the result,
# otherwise set result to NONDIR_REPLACEMENT.
func_dirname ()
{
func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
if test "X$func_dirname_result" = "X${1}"; then
func_dirname_result="${3}"
else
func_dirname_result="$func_dirname_result${2}"
fi
} # func_dirname may be replaced by extended shell implementation
# func_basename file
func_basename ()
{
func_basename_result=`$ECHO "${1}" | $SED "$basename"`
} # func_basename may be replaced by extended shell implementation
# func_dirname_and_basename file append nondir_replacement
# perform func_basename and func_dirname in a single function
# call:
# dirname: Compute the dirname of FILE. If nonempty,
# add APPEND to the result, otherwise set result
# to NONDIR_REPLACEMENT.
# value returned in "$func_dirname_result"
# basename: Compute filename of FILE.
# value retuned in "$func_basename_result"
# Implementation must be kept synchronized with func_dirname
# and func_basename. For efficiency, we do not delegate to
# those functions but instead duplicate the functionality here.
func_dirname_and_basename ()
{
# Extract subdirectory from the argument.
func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
if test "X$func_dirname_result" = "X${1}"; then
func_dirname_result="${3}"
else
func_dirname_result="$func_dirname_result${2}"
fi
func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
} # func_dirname_and_basename may be replaced by extended shell implementation
# func_stripname prefix suffix name
# strip PREFIX and SUFFIX off of NAME.
# PREFIX and SUFFIX must not contain globbing or regex special
# characters, hashes, percent signs, but SUFFIX may contain a leading
# dot (in which case that matches only a dot).
# func_strip_suffix prefix name
func_stripname ()
{
case ${2} in
.*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
esac
} # func_stripname may be replaced by extended shell implementation
# These SED scripts presuppose an absolute path with a trailing slash.
pathcar='s,^/\([^/]*\).*$,\1,'
pathcdr='s,^/[^/]*,,'
removedotparts=':dotsl
s@/\./@/@g
t dotsl
s,/\.$,/,'
collapseslashes='s@/\{1,\}@/@g'
finalslash='s,/*$,/,'
# func_normal_abspath PATH
# Remove doubled-up and trailing slashes, "." path components,
# and cancel out any ".." path components in PATH after making
# it an absolute path.
# value returned in "$func_normal_abspath_result"
func_normal_abspath ()
{
# Start from root dir and reassemble the path.
func_normal_abspath_result=
func_normal_abspath_tpath=$1
func_normal_abspath_altnamespace=
case $func_normal_abspath_tpath in
"")
# Empty path, that just means $cwd.
func_stripname '' '/' "`pwd`"
func_normal_abspath_result=$func_stripname_result
return
;;
# The next three entries are used to spot a run of precisely
# two leading slashes without using negated character classes;
# we take advantage of case's first-match behaviour.
///*)
# Unusual form of absolute path, do nothing.
;;
//*)
# Not necessarily an ordinary path; POSIX reserves leading '//'
# and for example Cygwin uses it to access remote file shares
# over CIFS/SMB, so we conserve a leading double slash if found.
func_normal_abspath_altnamespace=/
;;
/*)
# Absolute path, do nothing.
;;
*)
# Relative path, prepend $cwd.
func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
;;
esac
# Cancel out all the simple stuff to save iterations. We also want
# the path to end with a slash for ease of parsing, so make sure
# there is one (and only one) here.
func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
-e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
while :; do
# Processed it all yet?
if test "$func_normal_abspath_tpath" = / ; then
# If we ascended to the root using ".." the result may be empty now.
if test -z "$func_normal_abspath_result" ; then
func_normal_abspath_result=/
fi
break
fi
func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
-e "$pathcar"`
func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
-e "$pathcdr"`
# Figure out what to do with it
case $func_normal_abspath_tcomponent in
"")
# Trailing empty path component, ignore it.
;;
..)
# Parent dir; strip last assembled component from result.
func_dirname "$func_normal_abspath_result"
func_normal_abspath_result=$func_dirname_result
;;
*)
# Actual path component, append it.
func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
;;
esac
done
# Restore leading double-slash if one was found on entry.
func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
}
# func_relative_path SRCDIR DSTDIR
# generates a relative path from SRCDIR to DSTDIR, with a trailing
# slash if non-empty, suitable for immediately appending a filename
# without needing to append a separator.
# value returned in "$func_relative_path_result"
func_relative_path ()
{
func_relative_path_result=
func_normal_abspath "$1"
func_relative_path_tlibdir=$func_normal_abspath_result
func_normal_abspath "$2"
func_relative_path_tbindir=$func_normal_abspath_result
# Ascend the tree starting from libdir
while :; do
# check if we have found a prefix of bindir
case $func_relative_path_tbindir in
$func_relative_path_tlibdir)
# found an exact match
func_relative_path_tcancelled=
break
;;
$func_relative_path_tlibdir*)
# found a matching prefix
func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
func_relative_path_tcancelled=$func_stripname_result
if test -z "$func_relative_path_result"; then
func_relative_path_result=.
fi
break
;;
*)
func_dirname $func_relative_path_tlibdir
func_relative_path_tlibdir=${func_dirname_result}
if test "x$func_relative_path_tlibdir" = x ; then
# Have to descend all the way to the root!
func_relative_path_result=../$func_relative_path_result
func_relative_path_tcancelled=$func_relative_path_tbindir
break
fi
func_relative_path_result=../$func_relative_path_result
;;
esac
done
# Now calculate path; take care to avoid doubling-up slashes.
func_stripname '' '/' "$func_relative_path_result"
func_relative_path_result=$func_stripname_result
func_stripname '/' '/' "$func_relative_path_tcancelled"
if test "x$func_stripname_result" != x ; then
func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
fi
# Normalisation. If bindir is libdir, return empty string,
# else relative path ending with a slash; either way, target
# file name can be directly appended.
if test ! -z "$func_relative_path_result"; then
func_stripname './' '' "$func_relative_path_result/"
func_relative_path_result=$func_stripname_result
fi
}
# The name of this program:
func_dirname_and_basename "$progpath"
progname=$func_basename_result
# Make sure we have an absolute path for reexecution:
case $progpath in
[\\/]*|[A-Za-z]:\\*) ;;
*[\\/]*)
progdir=$func_dirname_result
progdir=`cd "$progdir" && pwd`
progpath="$progdir/$progname"
;;
*)
save_IFS="$IFS"
IFS=${PATH_SEPARATOR-:}
for progdir in $PATH; do
IFS="$save_IFS"
test -x "$progdir/$progname" && break
done
IFS="$save_IFS"
test -n "$progdir" || progdir=`pwd`
progpath="$progdir/$progname"
;;
esac
# Sed substitution that helps us do robust quoting. It backslashifies
# metacharacters that are still active within double-quoted strings.
Xsed="${SED}"' -e 1s/^X//'
sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
# Same as above, but do not quote variable references.
double_quote_subst='s/\(["`\\]\)/\\\1/g'
# Sed substitution that turns a string into a regex matching for the
# string literally.
sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
# Sed substitution that converts a w32 file name or path
# which contains forward slashes, into one that contains
# (escaped) backslashes. A very naive implementation.
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
# Re-`\' parameter expansions in output of double_quote_subst that were
# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
# in input to double_quote_subst, that '$' was protected from expansion.
# Since each input `\' is now two `\'s, look for any number of runs of
# four `\'s followed by two `\'s and then a '$'. `\' that '$'.
bs='\\'
bs2='\\\\'
bs4='\\\\\\\\'
dollar='\$'
sed_double_backslash="\
s/$bs4/&\\
/g
s/^$bs2$dollar/$bs&/
s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
s/\n//g"
# Standard options:
opt_dry_run=false
opt_help=false
opt_quiet=false
opt_verbose=false
opt_warning=:
# func_echo arg...
# Echo program name prefixed message, along with the current mode
# name if it has been set yet.
func_echo ()
{
$ECHO "$progname: ${opt_mode+$opt_mode: }$*"
}
# func_verbose arg...
# Echo program name prefixed message in verbose mode only.
func_verbose ()
{
$opt_verbose && func_echo ${1+"$@"}
# A bug in bash halts the script if the last line of a function
# fails when set -e is in force, so we need another command to
# work around that:
:
}
# func_echo_all arg...
# Invoke $ECHO with all args, space-separated.
func_echo_all ()
{
$ECHO "$*"
}
# func_error arg...
# Echo program name prefixed message to standard error.
func_error ()
{
$ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
}
# func_warning arg...
# Echo program name prefixed warning message to standard error.
func_warning ()
{
$opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
# bash bug again:
:
}
# func_fatal_error arg...
# Echo program name prefixed message to standard error, and exit.
func_fatal_error ()
{
func_error ${1+"$@"}
exit $EXIT_FAILURE
}
# func_fatal_help arg...
# Echo program name prefixed message to standard error, followed by
# a help hint, and exit.
func_fatal_help ()
{
func_error ${1+"$@"}
func_fatal_error "$help"
}
help="Try \`$progname --help' for more information." ## default
# func_grep expression filename
# Check whether EXPRESSION matches any line of FILENAME, without output.
func_grep ()
{
$GREP "$1" "$2" >/dev/null 2>&1
}
# func_mkdir_p directory-path
# Make sure the entire path to DIRECTORY-PATH is available.
func_mkdir_p ()
{
my_directory_path="$1"
my_dir_list=
if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
# Protect directory names starting with `-'
case $my_directory_path in
-*) my_directory_path="./$my_directory_path" ;;
esac
# While some portion of DIR does not yet exist...
while test ! -d "$my_directory_path"; do
# ...make a list in topmost first order. Use a colon delimited
# list incase some portion of path contains whitespace.
my_dir_list="$my_directory_path:$my_dir_list"
# If the last portion added has no slash in it, the list is done
case $my_directory_path in */*) ;; *) break ;; esac
# ...otherwise throw away the child directory and loop
my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
done
my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
save_mkdir_p_IFS="$IFS"; IFS=':'
for my_dir in $my_dir_list; do
IFS="$save_mkdir_p_IFS"
# mkdir can fail with a `File exist' error if two processes
# try to create one of the directories concurrently. Don't
# stop in that case!
$MKDIR "$my_dir" 2>/dev/null || :
done
IFS="$save_mkdir_p_IFS"
# Bail out if we (or some other process) failed to create a directory.
test -d "$my_directory_path" || \
func_fatal_error "Failed to create \`$1'"
fi
}
# func_mktempdir [string]
# Make a temporary directory that won't clash with other running
# libtool processes, and avoids race conditions if possible. If
# given, STRING is the basename for that directory.
func_mktempdir ()
{
my_template="${TMPDIR-/tmp}/${1-$progname}"
if test "$opt_dry_run" = ":"; then
# Return a directory name, but don't create it in dry-run mode
my_tmpdir="${my_template}-$$"
else
# If mktemp works, use that first and foremost
my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
if test ! -d "$my_tmpdir"; then
# Failing that, at least try and use $RANDOM to avoid a race
my_tmpdir="${my_template}-${RANDOM-0}$$"
save_mktempdir_umask=`umask`
umask 0077
$MKDIR "$my_tmpdir"
umask $save_mktempdir_umask
fi
# If we're not in dry-run mode, bomb out on failure
test -d "$my_tmpdir" || \
func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
fi
$ECHO "$my_tmpdir"
}
# func_quote_for_eval arg
# Aesthetically quote ARG to be evaled later.
# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
# is double-quoted, suitable for a subsequent eval, whereas
# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
# which are still active within double quotes backslashified.
func_quote_for_eval ()
{
case $1 in
*[\\\`\"\$]*)
func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
*)
func_quote_for_eval_unquoted_result="$1" ;;
esac
case $func_quote_for_eval_unquoted_result in
# Double-quote args containing shell metacharacters to delay
# word splitting, command substitution and and variable
# expansion for a subsequent eval.
# Many Bourne shells cannot handle close brackets correctly
# in scan sets, so we specify it separately.
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
;;
*)
func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
esac
}
# func_quote_for_expand arg
# Aesthetically quote ARG to be evaled later; same as above,
# but do not quote variable references.
func_quote_for_expand ()
{
case $1 in
*[\\\`\"]*)
my_arg=`$ECHO "$1" | $SED \
-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
*)
my_arg="$1" ;;
esac
case $my_arg in
# Double-quote args containing shell metacharacters to delay
# word splitting and command substitution for a subsequent eval.
# Many Bourne shells cannot handle close brackets correctly
# in scan sets, so we specify it separately.
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
my_arg="\"$my_arg\""
;;
esac
func_quote_for_expand_result="$my_arg"
}
# func_show_eval cmd [fail_exp]
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
# is given, then evaluate it.
func_show_eval ()
{
my_cmd="$1"
my_fail_exp="${2-:}"
${opt_silent-false} || {
func_quote_for_expand "$my_cmd"
eval "func_echo $func_quote_for_expand_result"
}
if ${opt_dry_run-false}; then :; else
eval "$my_cmd"
my_status=$?
if test "$my_status" -eq 0; then :; else
eval "(exit $my_status); $my_fail_exp"
fi
fi
}
# func_show_eval_locale cmd [fail_exp]
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
# is given, then evaluate it. Use the saved locale for evaluation.
func_show_eval_locale ()
{
my_cmd="$1"
my_fail_exp="${2-:}"
${opt_silent-false} || {
func_quote_for_expand "$my_cmd"
eval "func_echo $func_quote_for_expand_result"
}
if ${opt_dry_run-false}; then :; else
eval "$lt_user_locale
$my_cmd"
my_status=$?
eval "$lt_safe_locale"
if test "$my_status" -eq 0; then :; else
eval "(exit $my_status); $my_fail_exp"
fi
fi
}
# func_tr_sh
# Turn $1 into a string suitable for a shell variable name.
# Result is stored in $func_tr_sh_result. All characters
# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
# if $1 begins with a digit, a '_' is prepended as well.
func_tr_sh ()
{
case $1 in
[0-9]* | *[!a-zA-Z0-9_]*)
func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
;;
* )
func_tr_sh_result=$1
;;
esac
}
# func_version
# Echo version message to standard output and exit.
func_version ()
{
$opt_debug
$SED -n '/(C)/!b go
:more
/\./!{
N
s/\n# / /
b more
}
:go
/^# '$PROGRAM' (GNU /,/# warranty; / {
s/^# //
s/^# *$//
s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
p
}' < "$progpath"
exit $?
}
# func_usage
# Echo short help message to standard output and exit.
func_usage ()
{
$opt_debug
$SED -n '/^# Usage:/,/^# *.*--help/ {
s/^# //
s/^# *$//
s/\$progname/'$progname'/
p
}' < "$progpath"
echo
$ECHO "run \`$progname --help | more' for full usage"
exit $?
}
# func_help [NOEXIT]
# Echo long help message to standard output and exit,
# unless 'noexit' is passed as argument.
func_help ()
{
$opt_debug
$SED -n '/^# Usage:/,/# Report bugs to/ {
:print
s/^# //
s/^# *$//
s*\$progname*'$progname'*
s*\$host*'"$host"'*
s*\$SHELL*'"$SHELL"'*
s*\$LTCC*'"$LTCC"'*
s*\$LTCFLAGS*'"$LTCFLAGS"'*
s*\$LD*'"$LD"'*
s/\$with_gnu_ld/'"$with_gnu_ld"'/
s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
p
d
}
/^# .* home page:/b print
/^# General help using/b print
' < "$progpath"
ret=$?
if test -z "$1"; then
exit $ret
fi
}
# func_missing_arg argname
# Echo program name prefixed message to standard error and set global
# exit_cmd.
func_missing_arg ()
{
$opt_debug
func_error "missing argument for $1."
exit_cmd=exit
}
# func_split_short_opt shortopt
# Set func_split_short_opt_name and func_split_short_opt_arg shell
# variables after splitting SHORTOPT after the 2nd character.
func_split_short_opt ()
{
my_sed_short_opt='1s/^\(..\).*$/\1/;q'
my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
} # func_split_short_opt may be replaced by extended shell implementation
# func_split_long_opt longopt
# Set func_split_long_opt_name and func_split_long_opt_arg shell
# variables after splitting LONGOPT at the `=' sign.
func_split_long_opt ()
{
my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
my_sed_long_arg='1s/^--[^=]*=//'
func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
} # func_split_long_opt may be replaced by extended shell implementation
exit_cmd=:
magic="%%%MAGIC variable%%%"
magic_exe="%%%MAGIC EXE variable%%%"
# Global variables.
nonopt=
preserve_args=
lo2o="s/\\.lo\$/.${objext}/"
o2lo="s/\\.${objext}\$/.lo/"
extracted_archives=
extracted_serial=0
# If this variable is set in any of the actions, the command in it
# will be execed at the end. This prevents here-documents from being
# left over by shells.
exec_cmd=
# func_append var value
# Append VALUE to the end of shell variable VAR.
func_append ()
{
eval "${1}=\$${1}\${2}"
} # func_append may be replaced by extended shell implementation
# func_append_quoted var value
# Quote VALUE and append to the end of shell variable VAR, separated
# by a space.
func_append_quoted ()
{
func_quote_for_eval "${2}"
eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
} # func_append_quoted may be replaced by extended shell implementation
# func_arith arithmetic-term...
func_arith ()
{
func_arith_result=`expr "${@}"`
} # func_arith may be replaced by extended shell implementation
# func_len string
# STRING may not start with a hyphen.
func_len ()
{
func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
} # func_len may be replaced by extended shell implementation
# func_lo2o object
func_lo2o ()
{
func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
} # func_lo2o may be replaced by extended shell implementation
# func_xform libobj-or-source
func_xform ()
{
func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
} # func_xform may be replaced by extended shell implementation
# func_fatal_configuration arg...
# Echo program name prefixed message to standard error, followed by
# a configuration failure hint, and exit.
func_fatal_configuration ()
{
func_error ${1+"$@"}
func_error "See the $PACKAGE documentation for more information."
func_fatal_error "Fatal configuration error."
}
# func_config
# Display the configuration for all the tags in this script.
func_config ()
{
re_begincf='^# ### BEGIN LIBTOOL'
re_endcf='^# ### END LIBTOOL'
# Default configuration.
$SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
# Now print the configurations for the tags.
for tagname in $taglist; do
$SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
done
exit $?
}
# func_features
# Display the features supported by this script.
func_features ()
{
echo "host: $host"
if test "$build_libtool_libs" = yes; then
echo "enable shared libraries"
else
echo "disable shared libraries"
fi
if test "$build_old_libs" = yes; then
echo "enable static libraries"
else
echo "disable static libraries"
fi
exit $?
}
# func_enable_tag tagname
# Verify that TAGNAME is valid, and either flag an error and exit, or
# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
# variable here.
func_enable_tag ()
{
# Global variable:
tagname="$1"
re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
sed_extractcf="/$re_begincf/,/$re_endcf/p"
# Validate tagname.
case $tagname in
*[!-_A-Za-z0-9,/]*)
func_fatal_error "invalid tag name: $tagname"
;;
esac
# Don't test for the "default" C tag, as we know it's
# there but not specially marked.
case $tagname in
CC) ;;
*)
if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
taglist="$taglist $tagname"
# Evaluate the configuration. Be careful to quote the path
# and the sed script, to avoid splitting on whitespace, but
# also don't use non-portable quotes within backquotes within
# quotes we have to do it in 2 steps:
extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
eval "$extractedcf"
else
func_error "ignoring unknown tag $tagname"
fi
;;
esac
}
# func_check_version_match
# Ensure that we are using m4 macros, and libtool script from the same
# release of libtool.
func_check_version_match ()
{
if test "$package_revision" != "$macro_revision"; then
if test "$VERSION" != "$macro_version"; then
if test -z "$macro_version"; then
cat >&2 <<_LT_EOF
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
$progname: definition of this LT_INIT comes from an older release.
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
$progname: and run autoconf again.
_LT_EOF
else
cat >&2 <<_LT_EOF
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
$progname: and run autoconf again.
_LT_EOF
fi
else
cat >&2 <<_LT_EOF
$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
$progname: but the definition of this LT_INIT comes from revision $macro_revision.
$progname: You should recreate aclocal.m4 with macros from revision $package_revision
$progname: of $PACKAGE $VERSION and run autoconf again.
_LT_EOF
fi
exit $EXIT_MISMATCH
fi
}
# Shorthand for --mode=foo, only valid as the first argument
case $1 in
clean|clea|cle|cl)
shift; set dummy --mode clean ${1+"$@"}; shift
;;
compile|compil|compi|comp|com|co|c)
shift; set dummy --mode compile ${1+"$@"}; shift
;;
execute|execut|execu|exec|exe|ex|e)
shift; set dummy --mode execute ${1+"$@"}; shift
;;
finish|finis|fini|fin|fi|f)
shift; set dummy --mode finish ${1+"$@"}; shift
;;
install|instal|insta|inst|ins|in|i)
shift; set dummy --mode install ${1+"$@"}; shift
;;
link|lin|li|l)
shift; set dummy --mode link ${1+"$@"}; shift
;;
uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
shift; set dummy --mode uninstall ${1+"$@"}; shift
;;
esac
# Option defaults:
opt_debug=:
opt_dry_run=false
opt_config=false
opt_preserve_dup_deps=false
opt_features=false
opt_finish=false
opt_help=false
opt_help_all=false
opt_silent=:
opt_warning=:
opt_verbose=:
opt_silent=false
opt_verbose=false
# Parse options once, thoroughly. This comes as soon as possible in the
# script to make things like `--version' happen as quickly as we can.
{
# this just eases exit handling
while test $# -gt 0; do
opt="$1"
shift
case $opt in
--debug|-x) opt_debug='set -x'
func_echo "enabling shell trace mode"
$opt_debug
;;
--dry-run|--dryrun|-n)
opt_dry_run=:
;;
--config)
opt_config=:
func_config
;;
--dlopen|-dlopen)
optarg="$1"
opt_dlopen="${opt_dlopen+$opt_dlopen
}$optarg"
shift
;;
--preserve-dup-deps)
opt_preserve_dup_deps=:
;;
--features)
opt_features=:
func_features
;;
--finish)
opt_finish=:
set dummy --mode finish ${1+"$@"}; shift
;;
--help)
opt_help=:
;;
--help-all)
opt_help_all=:
opt_help=': help-all'
;;
--mode)
test $# = 0 && func_missing_arg $opt && break
optarg="$1"
opt_mode="$optarg"
case $optarg in
# Valid mode arguments:
clean|compile|execute|finish|install|link|relink|uninstall) ;;
# Catch anything else as an error
*) func_error "invalid argument for $opt"
exit_cmd=exit
break
;;
esac
shift
;;
--no-silent|--no-quiet)
opt_silent=false
func_append preserve_args " $opt"
;;
--no-warning|--no-warn)
opt_warning=false
func_append preserve_args " $opt"
;;
--no-verbose)
opt_verbose=false
func_append preserve_args " $opt"
;;
--silent|--quiet)
opt_silent=:
func_append preserve_args " $opt"
opt_verbose=false
;;
--verbose|-v)
opt_verbose=:
func_append preserve_args " $opt"
opt_silent=false
;;
--tag)
test $# = 0 && func_missing_arg $opt && break
optarg="$1"
opt_tag="$optarg"
func_append preserve_args " $opt $optarg"
func_enable_tag "$optarg"
shift
;;
-\?|-h) func_usage ;;
--help) func_help ;;
--version) func_version ;;
# Separate optargs to long options:
--*=*)
func_split_long_opt "$opt"
set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
shift
;;
# Separate non-argument short options:
-\?*|-h*|-n*|-v*)
func_split_short_opt "$opt"
set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
shift
;;
--) break ;;
-*) func_fatal_help "unrecognized option \`$opt'" ;;
*) set dummy "$opt" ${1+"$@"}; shift; break ;;
esac
done
# Validate options:
# save first non-option argument
if test "$#" -gt 0; then
nonopt="$opt"
shift
fi
# preserve --debug
test "$opt_debug" = : || func_append preserve_args " --debug"
case $host in
*cygwin* | *mingw* | *pw32* | *cegcc*)
# don't eliminate duplications in $postdeps and $predeps
opt_duplicate_compiler_generated_deps=:
;;
*)
opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
;;
esac
$opt_help || {
# Sanity checks first:
func_check_version_match
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
func_fatal_configuration "not configured to build any kind of library"
fi
# Darwin sucks
eval std_shrext=\"$shrext_cmds\"
# Only execute mode is allowed to have -dlopen flags.
if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
func_error "unrecognized option \`-dlopen'"
$ECHO "$help" 1>&2
exit $EXIT_FAILURE
fi
# Change the help message to a mode-specific one.
generic_help="$help"
help="Try \`$progname --help --mode=$opt_mode' for more information."
}
# Bail if the options were screwed
$exit_cmd $EXIT_FAILURE
}
## ----------- ##
## Main. ##
## ----------- ##
# func_lalib_p file
# True iff FILE is a libtool `.la' library or `.lo' object file.
# This function is only a basic sanity check; it will hardly flush out
# determined imposters.
func_lalib_p ()
{
test -f "$1" &&
$SED -e 4q "$1" 2>/dev/null \
| $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
}
# func_lalib_unsafe_p file
# True iff FILE is a libtool `.la' library or `.lo' object file.
# This function implements the same check as func_lalib_p without
# resorting to external programs. To this end, it redirects stdin and
# closes it afterwards, without saving the original file descriptor.
# As a safety measure, use it only where a negative result would be
# fatal anyway. Works if `file' does not exist.
func_lalib_unsafe_p ()
{
lalib_p=no
if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
for lalib_p_l in 1 2 3 4
do
read lalib_p_line
case "$lalib_p_line" in
\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
esac
done
exec 0<&5 5<&-
fi
test "$lalib_p" = yes
}
# func_ltwrapper_script_p file
# True iff FILE is a libtool wrapper script
# This function is only a basic sanity check; it will hardly flush out
# determined imposters.
func_ltwrapper_script_p ()
{
func_lalib_p "$1"
}
# func_ltwrapper_executable_p file
# True iff FILE is a libtool wrapper executable
# This function is only a basic sanity check; it will hardly flush out
# determined imposters.
func_ltwrapper_executable_p ()
{
func_ltwrapper_exec_suffix=
case $1 in
*.exe) ;;
*) func_ltwrapper_exec_suffix=.exe ;;
esac
$GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
}
# func_ltwrapper_scriptname file
# Assumes file is an ltwrapper_executable
# uses $file to determine the appropriate filename for a
# temporary ltwrapper_script.
func_ltwrapper_scriptname ()
{
func_dirname_and_basename "$1" "" "."
func_stripname '' '.exe' "$func_basename_result"
func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
}
# func_ltwrapper_p file
# True iff FILE is a libtool wrapper script or wrapper executable
# This function is only a basic sanity check; it will hardly flush out
# determined imposters.
func_ltwrapper_p ()
{
func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
}
# func_execute_cmds commands fail_cmd
# Execute tilde-delimited COMMANDS.
# If FAIL_CMD is given, eval that upon failure.
# FAIL_CMD may read-access the current command in variable CMD!
func_execute_cmds ()
{
$opt_debug
save_ifs=$IFS; IFS='~'
for cmd in $1; do
IFS=$save_ifs
eval cmd=\"$cmd\"
func_show_eval "$cmd" "${2-:}"
done
IFS=$save_ifs
}
# func_source file
# Source FILE, adding directory component if necessary.
# Note that it is not necessary on cygwin/mingw to append a dot to
# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
# behavior happens only for exec(3), not for open(2)! Also, sourcing
# `FILE.' does not work on cygwin managed mounts.
func_source ()
{
$opt_debug
case $1 in
*/* | *\\*) . "$1" ;;
*) . "./$1" ;;
esac
}
# func_resolve_sysroot PATH
# Replace a leading = in PATH with a sysroot. Store the result into
# func_resolve_sysroot_result
func_resolve_sysroot ()
{
func_resolve_sysroot_result=$1
case $func_resolve_sysroot_result in
=*)
func_stripname '=' '' "$func_resolve_sysroot_result"
func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
;;
esac
}
# func_replace_sysroot PATH
# If PATH begins with the sysroot, replace it with = and
# store the result into func_replace_sysroot_result.
func_replace_sysroot ()
{
case "$lt_sysroot:$1" in
?*:"$lt_sysroot"*)
func_stripname "$lt_sysroot" '' "$1"
func_replace_sysroot_result="=$func_stripname_result"
;;
*)
# Including no sysroot.
func_replace_sysroot_result=$1
;;
esac
}
# func_infer_tag arg
# Infer tagged configuration to use if any are available and
# if one wasn't chosen via the "--tag" command line option.
# Only attempt this if the compiler in the base compile
# command doesn't match the default compiler.
# arg is usually of the form 'gcc ...'
func_infer_tag ()
{
$opt_debug
if test -n "$available_tags" && test -z "$tagname"; then
CC_quoted=
for arg in $CC; do
func_append_quoted CC_quoted "$arg"
done
CC_expanded=`func_echo_all $CC`
CC_quoted_expanded=`func_echo_all $CC_quoted`
case $@ in
# Blanks in the command may have been stripped by the calling shell,
# but not from the CC environment variable when configure was run.
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
# Blanks at the start of $base_compile will cause this to fail
# if we don't check for them as well.
*)
for z in $available_tags; do
if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
# Evaluate the configuration.
eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
CC_quoted=
for arg in $CC; do
# Double-quote args containing other shell metacharacters.
func_append_quoted CC_quoted "$arg"
done
CC_expanded=`func_echo_all $CC`
CC_quoted_expanded=`func_echo_all $CC_quoted`
case "$@ " in
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
# The compiler in the base compile command matches
# the one in the tagged configuration.
# Assume this is the tagged configuration we want.
tagname=$z
break
;;
esac
fi
done
# If $tagname still isn't set, then no tagged configuration
# was found and let the user know that the "--tag" command
# line option must be used.
if test -z "$tagname"; then
func_echo "unable to infer tagged configuration"
func_fatal_error "specify a tag with \`--tag'"
# else
# func_verbose "using $tagname tagged configuration"
fi
;;
esac
fi
}
# func_write_libtool_object output_name pic_name nonpic_name
# Create a libtool object file (analogous to a ".la" file),
# but don't create it if we're doing a dry run.
func_write_libtool_object ()
{
write_libobj=${1}
if test "$build_libtool_libs" = yes; then
write_lobj=\'${2}\'
else
write_lobj=none
fi
if test "$build_old_libs" = yes; then
write_oldobj=\'${3}\'
else
write_oldobj=none
fi
$opt_dry_run || {
cat >${write_libobj}T <<EOF
# $write_libobj - a libtool object file
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
#
# Please DO NOT delete this file!
# It is necessary for linking the library.
# Name of the PIC object.
pic_object=$write_lobj
# Name of the non-PIC object
non_pic_object=$write_oldobj
EOF
$MV "${write_libobj}T" "${write_libobj}"
}
}
##################################################
# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
##################################################
# func_convert_core_file_wine_to_w32 ARG
# Helper function used by file name conversion functions when $build is *nix,
# and $host is mingw, cygwin, or some other w32 environment. Relies on a
# correctly configured wine environment available, with the winepath program
# in $build's $PATH.
#
# ARG is the $build file name to be converted to w32 format.
# Result is available in $func_convert_core_file_wine_to_w32_result, and will
# be empty on error (or when ARG is empty)
func_convert_core_file_wine_to_w32 ()
{
$opt_debug
func_convert_core_file_wine_to_w32_result="$1"
if test -n "$1"; then
# Unfortunately, winepath does not exit with a non-zero error code, so we
# are forced to check the contents of stdout. On the other hand, if the
# command is not found, the shell will set an exit code of 127 and print
# *an error message* to stdout. So we must check for both error code of
# zero AND non-empty stdout, which explains the odd construction:
func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
$SED -e "$lt_sed_naive_backslashify"`
else
func_convert_core_file_wine_to_w32_result=
fi
fi
}
# end: func_convert_core_file_wine_to_w32
# func_convert_core_path_wine_to_w32 ARG
# Helper function used by path conversion functions when $build is *nix, and
# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
# configured wine environment available, with the winepath program in $build's
# $PATH. Assumes ARG has no leading or trailing path separator characters.
#
# ARG is path to be converted from $build format to win32.
# Result is available in $func_convert_core_path_wine_to_w32_result.
# Unconvertible file (directory) names in ARG are skipped; if no directory names
# are convertible, then the result may be empty.
func_convert_core_path_wine_to_w32 ()
{
$opt_debug
# unfortunately, winepath doesn't convert paths, only file names
func_convert_core_path_wine_to_w32_result=""
if test -n "$1"; then
oldIFS=$IFS
IFS=:
for func_convert_core_path_wine_to_w32_f in $1; do
IFS=$oldIFS
func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
if test -n "$func_convert_core_file_wine_to_w32_result" ; then
if test -z "$func_convert_core_path_wine_to_w32_result"; then
func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
else
func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
fi
fi
done
IFS=$oldIFS
fi
}
# end: func_convert_core_path_wine_to_w32
# func_cygpath ARGS...
# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
# (2), returns the Cygwin file name or path in func_cygpath_result (input
# file name or path is assumed to be in w32 format, as previously converted
# from $build's *nix or MSYS format). In case (3), returns the w32 file name
# or path in func_cygpath_result (input file name or path is assumed to be in
# Cygwin format). Returns an empty string on error.
#
# ARGS are passed to cygpath, with the last one being the file name or path to
# be converted.
#
# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
# environment variable; do not put it in $PATH.
func_cygpath ()
{
$opt_debug
if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
if test "$?" -ne 0; then
# on failure, ensure result is empty
func_cygpath_result=
fi
else
func_cygpath_result=
func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
fi
}
#end: func_cygpath
# func_convert_core_msys_to_w32 ARG
# Convert file name or path ARG from MSYS format to w32 format. Return
# result in func_convert_core_msys_to_w32_result.
func_convert_core_msys_to_w32 ()
{
$opt_debug
# awkward: cmd appends spaces to result
func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
$SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
}
#end: func_convert_core_msys_to_w32
# func_convert_file_check ARG1 ARG2
# Verify that ARG1 (a file name in $build format) was converted to $host
# format in ARG2. Otherwise, emit an error message, but continue (resetting
# func_to_host_file_result to ARG1).
func_convert_file_check ()
{
$opt_debug
if test -z "$2" && test -n "$1" ; then
func_error "Could not determine host file name corresponding to"
func_error " \`$1'"
func_error "Continuing, but uninstalled executables may not work."
# Fallback:
func_to_host_file_result="$1"
fi
}
# end func_convert_file_check
# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
# Verify that FROM_PATH (a path in $build format) was converted to $host
# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
# func_to_host_file_result to a simplistic fallback value (see below).
func_convert_path_check ()
{
$opt_debug
if test -z "$4" && test -n "$3"; then
func_error "Could not determine the host path corresponding to"
func_error " \`$3'"
func_error "Continuing, but uninstalled executables may not work."
# Fallback. This is a deliberately simplistic "conversion" and
# should not be "improved". See libtool.info.
if test "x$1" != "x$2"; then
lt_replace_pathsep_chars="s|$1|$2|g"
func_to_host_path_result=`echo "$3" |
$SED -e "$lt_replace_pathsep_chars"`
else
func_to_host_path_result="$3"
fi
fi
}
# end func_convert_path_check
# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
# and appending REPL if ORIG matches BACKPAT.
func_convert_path_front_back_pathsep ()
{
$opt_debug
case $4 in
$1 ) func_to_host_path_result="$3$func_to_host_path_result"
;;
esac
case $4 in
$2 ) func_append func_to_host_path_result "$3"
;;
esac
}
# end func_convert_path_front_back_pathsep
##################################################
# $build to $host FILE NAME CONVERSION FUNCTIONS #
##################################################
# invoked via `$to_host_file_cmd ARG'
#
# In each case, ARG is the path to be converted from $build to $host format.
# Result will be available in $func_to_host_file_result.
# func_to_host_file ARG
# Converts the file name ARG from $build format to $host format. Return result
# in func_to_host_file_result.
func_to_host_file ()
{
$opt_debug
$to_host_file_cmd "$1"
}
# end func_to_host_file
# func_to_tool_file ARG LAZY
# converts the file name ARG from $build format to toolchain format. Return
# result in func_to_tool_file_result. If the conversion in use is listed
# in (the comma separated) LAZY, no conversion takes place.
func_to_tool_file ()
{
$opt_debug
case ,$2, in
*,"$to_tool_file_cmd",*)
func_to_tool_file_result=$1
;;
*)
$to_tool_file_cmd "$1"
func_to_tool_file_result=$func_to_host_file_result
;;
esac
}
# end func_to_tool_file
# func_convert_file_noop ARG
# Copy ARG to func_to_host_file_result.
func_convert_file_noop ()
{
func_to_host_file_result="$1"
}
# end func_convert_file_noop
# func_convert_file_msys_to_w32 ARG
# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
# conversion to w32 is not available inside the cwrapper. Returns result in
# func_to_host_file_result.
func_convert_file_msys_to_w32 ()
{
$opt_debug
func_to_host_file_result="$1"
if test -n "$1"; then
func_convert_core_msys_to_w32 "$1"
func_to_host_file_result="$func_convert_core_msys_to_w32_result"
fi
func_convert_file_check "$1" "$func_to_host_file_result"
}
# end func_convert_file_msys_to_w32
# func_convert_file_cygwin_to_w32 ARG
# Convert file name ARG from Cygwin to w32 format. Returns result in
# func_to_host_file_result.
func_convert_file_cygwin_to_w32 ()
{
$opt_debug
func_to_host_file_result="$1"
if test -n "$1"; then
# because $build is cygwin, we call "the" cygpath in $PATH; no need to use
# LT_CYGPATH in this case.
func_to_host_file_result=`cygpath -m "$1"`
fi
func_convert_file_check "$1" "$func_to_host_file_result"
}
# end func_convert_file_cygwin_to_w32
# func_convert_file_nix_to_w32 ARG
# Convert file name ARG from *nix to w32 format. Requires a wine environment
# and a working winepath. Returns result in func_to_host_file_result.
func_convert_file_nix_to_w32 ()
{
$opt_debug
func_to_host_file_result="$1"
if test -n "$1"; then
func_convert_core_file_wine_to_w32 "$1"
func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
fi
func_convert_file_check "$1" "$func_to_host_file_result"
}
# end func_convert_file_nix_to_w32
# func_convert_file_msys_to_cygwin ARG
# Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
# Returns result in func_to_host_file_result.
func_convert_file_msys_to_cygwin ()
{
$opt_debug
func_to_host_file_result="$1"
if test -n "$1"; then
func_convert_core_msys_to_w32 "$1"
func_cygpath -u "$func_convert_core_msys_to_w32_result"
func_to_host_file_result="$func_cygpath_result"
fi
func_convert_file_check "$1" "$func_to_host_file_result"
}
# end func_convert_file_msys_to_cygwin
# func_convert_file_nix_to_cygwin ARG
# Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
# in a wine environment, working winepath, and LT_CYGPATH set. Returns result
# in func_to_host_file_result.
func_convert_file_nix_to_cygwin ()
{
$opt_debug
func_to_host_file_result="$1"
if test -n "$1"; then
# convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
func_convert_core_file_wine_to_w32 "$1"
func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
func_to_host_file_result="$func_cygpath_result"
fi
func_convert_file_check "$1" "$func_to_host_file_result"
}
# end func_convert_file_nix_to_cygwin
#############################################
# $build to $host PATH CONVERSION FUNCTIONS #
#############################################
# invoked via `$to_host_path_cmd ARG'
#
# In each case, ARG is the path to be converted from $build to $host format.
# The result will be available in $func_to_host_path_result.
#
# Path separators are also converted from $build format to $host format. If
# ARG begins or ends with a path separator character, it is preserved (but
# converted to $host format) on output.
#
# All path conversion functions are named using the following convention:
# file name conversion function : func_convert_file_X_to_Y ()
# path conversion function : func_convert_path_X_to_Y ()
# where, for any given $build/$host combination the 'X_to_Y' value is the
# same. If conversion functions are added for new $build/$host combinations,
# the two new functions must follow this pattern, or func_init_to_host_path_cmd
# will break.
# func_init_to_host_path_cmd
# Ensures that function "pointer" variable $to_host_path_cmd is set to the
# appropriate value, based on the value of $to_host_file_cmd.
to_host_path_cmd=
func_init_to_host_path_cmd ()
{
$opt_debug
if test -z "$to_host_path_cmd"; then
func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
to_host_path_cmd="func_convert_path_${func_stripname_result}"
fi
}
# func_to_host_path ARG
# Converts the path ARG from $build format to $host format. Return result
# in func_to_host_path_result.
func_to_host_path ()
{
$opt_debug
func_init_to_host_path_cmd
$to_host_path_cmd "$1"
}
# end func_to_host_path
# func_convert_path_noop ARG
# Copy ARG to func_to_host_path_result.
func_convert_path_noop ()
{
func_to_host_path_result="$1"
}
# end func_convert_path_noop
# func_convert_path_msys_to_w32 ARG
# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
# conversion to w32 is not available inside the cwrapper. Returns result in
# func_to_host_path_result.
func_convert_path_msys_to_w32 ()
{
$opt_debug
func_to_host_path_result="$1"
if test -n "$1"; then
# Remove leading and trailing path separator characters from ARG. MSYS
# behavior is inconsistent here; cygpath turns them into '.;' and ';.';
# and winepath ignores them completely.
func_stripname : : "$1"
func_to_host_path_tmp1=$func_stripname_result
func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
func_to_host_path_result="$func_convert_core_msys_to_w32_result"
func_convert_path_check : ";" \
"$func_to_host_path_tmp1" "$func_to_host_path_result"
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
fi
}
# end func_convert_path_msys_to_w32
# func_convert_path_cygwin_to_w32 ARG
# Convert path ARG from Cygwin to w32 format. Returns result in
# func_to_host_file_result.
func_convert_path_cygwin_to_w32 ()
{
$opt_debug
func_to_host_path_result="$1"
if test -n "$1"; then
# See func_convert_path_msys_to_w32:
func_stripname : : "$1"
func_to_host_path_tmp1=$func_stripname_result
func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
func_convert_path_check : ";" \
"$func_to_host_path_tmp1" "$func_to_host_path_result"
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
fi
}
# end func_convert_path_cygwin_to_w32
# func_convert_path_nix_to_w32 ARG
# Convert path ARG from *nix to w32 format. Requires a wine environment and
# a working winepath. Returns result in func_to_host_file_result.
func_convert_path_nix_to_w32 ()
{
$opt_debug
func_to_host_path_result="$1"
if test -n "$1"; then
# See func_convert_path_msys_to_w32:
func_stripname : : "$1"
func_to_host_path_tmp1=$func_stripname_result
func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
func_convert_path_check : ";" \
"$func_to_host_path_tmp1" "$func_to_host_path_result"
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
fi
}
# end func_convert_path_nix_to_w32
# func_convert_path_msys_to_cygwin ARG
# Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
# Returns result in func_to_host_file_result.
func_convert_path_msys_to_cygwin ()
{
$opt_debug
func_to_host_path_result="$1"
if test -n "$1"; then
# See func_convert_path_msys_to_w32:
func_stripname : : "$1"
func_to_host_path_tmp1=$func_stripname_result
func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
func_to_host_path_result="$func_cygpath_result"
func_convert_path_check : : \
"$func_to_host_path_tmp1" "$func_to_host_path_result"
func_convert_path_front_back_pathsep ":*" "*:" : "$1"
fi
}
# end func_convert_path_msys_to_cygwin
# func_convert_path_nix_to_cygwin ARG
# Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
# a wine environment, working winepath, and LT_CYGPATH set. Returns result in
# func_to_host_file_result.
func_convert_path_nix_to_cygwin ()
{
$opt_debug
func_to_host_path_result="$1"
if test -n "$1"; then
# Remove leading and trailing path separator characters from
# ARG. msys behavior is inconsistent here, cygpath turns them
# into '.;' and ';.', and winepath ignores them completely.
func_stripname : : "$1"
func_to_host_path_tmp1=$func_stripname_result
func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
func_to_host_path_result="$func_cygpath_result"
func_convert_path_check : : \
"$func_to_host_path_tmp1" "$func_to_host_path_result"
func_convert_path_front_back_pathsep ":*" "*:" : "$1"
fi
}
# end func_convert_path_nix_to_cygwin
# func_mode_compile arg...
func_mode_compile ()
{
$opt_debug
# Get the compilation command and the source file.
base_compile=
srcfile="$nonopt" # always keep a non-empty value in "srcfile"
suppress_opt=yes
suppress_output=
arg_mode=normal
libobj=
later=
pie_flag=
for arg
do
case $arg_mode in
arg )
# do not "continue". Instead, add this to base_compile
lastarg="$arg"
arg_mode=normal
;;
target )
libobj="$arg"
arg_mode=normal
continue
;;
normal )
# Accept any command-line options.
case $arg in
-o)
test -n "$libobj" && \
func_fatal_error "you cannot specify \`-o' more than once"
arg_mode=target
continue
;;
-pie | -fpie | -fPIE)
func_append pie_flag " $arg"
continue
;;
-shared | -static | -prefer-pic | -prefer-non-pic)
func_append later " $arg"
continue
;;
-no-suppress)
suppress_opt=no
continue
;;
-Xcompiler)
arg_mode=arg # the next one goes into the "base_compile" arg list
continue # The current "srcfile" will either be retained or
;; # replaced later. I would guess that would be a bug.
-Wc,*)
func_stripname '-Wc,' '' "$arg"
args=$func_stripname_result
lastarg=
save_ifs="$IFS"; IFS=','
for arg in $args; do
IFS="$save_ifs"
func_append_quoted lastarg "$arg"
done
IFS="$save_ifs"
func_stripname ' ' '' "$lastarg"
lastarg=$func_stripname_result
# Add the arguments to base_compile.
func_append base_compile " $lastarg"
continue
;;
*)
# Accept the current argument as the source file.
# The previous "srcfile" becomes the current argument.
#
lastarg="$srcfile"
srcfile="$arg"
;;
esac # case $arg
;;
esac # case $arg_mode
# Aesthetically quote the previous argument.
func_append_quoted base_compile "$lastarg"
done # for arg
case $arg_mode in
arg)
func_fatal_error "you must specify an argument for -Xcompile"
;;
target)
func_fatal_error "you must specify a target with \`-o'"
;;
*)
# Get the name of the library object.
test -z "$libobj" && {
func_basename "$srcfile"
libobj="$func_basename_result"
}
;;
esac
# Recognize several different file suffixes.
# If the user specifies -o file.o, it is replaced with file.lo
case $libobj in
*.[cCFSifmso] | \
*.ada | *.adb | *.ads | *.asm | \
*.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
*.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
func_xform "$libobj"
libobj=$func_xform_result
;;
esac
case $libobj in
*.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
*)
func_fatal_error "cannot determine name of library object from \`$libobj'"
;;
esac
func_infer_tag $base_compile
for arg in $later; do
case $arg in
-shared)
test "$build_libtool_libs" != yes && \
func_fatal_configuration "can not build a shared library"
build_old_libs=no
continue
;;
-static)
build_libtool_libs=no
build_old_libs=yes
continue
;;
-prefer-pic)
pic_mode=yes
continue
;;
-prefer-non-pic)
pic_mode=no
continue
;;
esac
done
func_quote_for_eval "$libobj"
test "X$libobj" != "X$func_quote_for_eval_result" \
&& $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
&& func_warning "libobj name \`$libobj' may not contain shell special characters."
func_dirname_and_basename "$obj" "/" ""
objname="$func_basename_result"
xdir="$func_dirname_result"
lobj=${xdir}$objdir/$objname
test -z "$base_compile" && \
func_fatal_help "you must specify a compilation command"
# Delete any leftover library objects.
if test "$build_old_libs" = yes; then
removelist="$obj $lobj $libobj ${libobj}T"
else
removelist="$lobj $libobj ${libobj}T"
fi
# On Cygwin there's no "real" PIC flag so we must build both object types
case $host_os in
cygwin* | mingw* | pw32* | os2* | cegcc*)
pic_mode=default
;;
esac
if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
# non-PIC code in shared libraries is not supported
pic_mode=default
fi
# Calculate the filename of the output object if compiler does
# not support -o with -c
if test "$compiler_c_o" = no; then
output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
lockfile="$output_obj.lock"
else
output_obj=
need_locks=no
lockfile=
fi
# Lock this critical section if it is needed
# We use this script file to make the link, it avoids creating a new file
if test "$need_locks" = yes; then
until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
func_echo "Waiting for $lockfile to be removed"
sleep 2
done
elif test "$need_locks" = warn; then
if test -f "$lockfile"; then
$ECHO "\
*** ERROR, $lockfile exists and contains:
`cat $lockfile 2>/dev/null`
This indicates that another process is trying to use the same
temporary object file, and libtool could not work around it because
your compiler does not support \`-c' and \`-o' together. If you
repeat this compilation, it may succeed, by chance, but you had better
avoid parallel builds (make -j) in this platform, or get a better
compiler."
$opt_dry_run || $RM $removelist
exit $EXIT_FAILURE
fi
func_append removelist " $output_obj"
$ECHO "$srcfile" > "$lockfile"
fi
$opt_dry_run || $RM $removelist
func_append removelist " $lockfile"
trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
srcfile=$func_to_tool_file_result
func_quote_for_eval "$srcfile"
qsrcfile=$func_quote_for_eval_result
# Only build a PIC object if we are building libtool libraries.
if test "$build_libtool_libs" = yes; then
# Without this assignment, base_compile gets emptied.
fbsd_hideous_sh_bug=$base_compile
if test "$pic_mode" != no; then
command="$base_compile $qsrcfile $pic_flag"
else
# Don't build PIC code
command="$base_compile $qsrcfile"
fi
func_mkdir_p "$xdir$objdir"
if test -z "$output_obj"; then
# Place PIC objects in $objdir
func_append command " -o $lobj"
fi
func_show_eval_locale "$command" \
'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
if test "$need_locks" = warn &&
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
$ECHO "\
*** ERROR, $lockfile contains:
`cat $lockfile 2>/dev/null`
but it should contain:
$srcfile
This indicates that another process is trying to use the same
temporary object file, and libtool could not work around it because
your compiler does not support \`-c' and \`-o' together. If you
repeat this compilation, it may succeed, by chance, but you had better
avoid parallel builds (make -j) in this platform, or get a better
compiler."
$opt_dry_run || $RM $removelist
exit $EXIT_FAILURE
fi
# Just move the object if needed, then go on to compile the next one
if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
func_show_eval '$MV "$output_obj" "$lobj"' \
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
fi
# Allow error messages only from the first compilation.
if test "$suppress_opt" = yes; then
suppress_output=' >/dev/null 2>&1'
fi
fi
# Only build a position-dependent object if we build old libraries.
if test "$build_old_libs" = yes; then
if test "$pic_mode" != yes; then
# Don't build PIC code
command="$base_compile $qsrcfile$pie_flag"
else
command="$base_compile $qsrcfile $pic_flag"
fi
if test "$compiler_c_o" = yes; then
func_append command " -o $obj"
fi
# Suppress compiler output if we already did a PIC compilation.
func_append command "$suppress_output"
func_show_eval_locale "$command" \
'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
if test "$need_locks" = warn &&
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
$ECHO "\
*** ERROR, $lockfile contains:
`cat $lockfile 2>/dev/null`
but it should contain:
$srcfile
This indicates that another process is trying to use the same
temporary object file, and libtool could not work around it because
your compiler does not support \`-c' and \`-o' together. If you
repeat this compilation, it may succeed, by chance, but you had better
avoid parallel builds (make -j) in this platform, or get a better
compiler."
$opt_dry_run || $RM $removelist
exit $EXIT_FAILURE
fi
# Just move the object if needed
if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
func_show_eval '$MV "$output_obj" "$obj"' \
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
fi
fi
$opt_dry_run || {
func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
# Unlock the critical section if it was locked
if test "$need_locks" != no; then
removelist=$lockfile
$RM "$lockfile"
fi
}
exit $EXIT_SUCCESS
}
$opt_help || {
test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
}
func_mode_help ()
{
# We need to display help for each of the modes.
case $opt_mode in
"")
# Generic help is extracted from the usage comments
# at the start of this file.
func_help
;;
clean)
$ECHO \
"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
Remove files from the build directory.
RM is the name of the program to use to delete files associated with each FILE
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
to RM.
If FILE is a libtool library, object or program, all the files associated
with it are deleted. Otherwise, only FILE itself is deleted using RM."
;;
compile)
$ECHO \
"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
Compile a source file into a libtool library object.
This mode accepts the following additional options:
-o OUTPUT-FILE set the output file name to OUTPUT-FILE
-no-suppress do not suppress compiler output for multiple passes
-prefer-pic try to build PIC objects only
-prefer-non-pic try to build non-PIC objects only
-shared do not build a \`.o' file suitable for static linking
-static only build a \`.o' file suitable for static linking
-Wc,FLAG pass FLAG directly to the compiler
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
from the given SOURCEFILE.
The output file name is determined by removing the directory component from
SOURCEFILE, then substituting the C source code suffix \`.c' with the
library object suffix, \`.lo'."
;;
execute)
$ECHO \
"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
Automatically set library path, then run a program.
This mode accepts the following additional options:
-dlopen FILE add the directory containing FILE to the library path
This mode sets the library path environment variable according to \`-dlopen'
flags.
If any of the ARGS are libtool executable wrappers, then they are translated
into their corresponding uninstalled binary, and any of their required library
directories are added to the library path.
Then, COMMAND is executed, with ARGS as arguments."
;;
finish)
$ECHO \
"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
Complete the installation of libtool libraries.
Each LIBDIR is a directory that contains libtool libraries.
The commands that this mode executes may require superuser privileges. Use
the \`--dry-run' option if you just want to see what would be executed."
;;
install)
$ECHO \
"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
Install executables or libraries.
INSTALL-COMMAND is the installation command. The first component should be
either the \`install' or \`cp' program.
The following components of INSTALL-COMMAND are treated specially:
-inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
The rest of the components are interpreted as arguments to that command (only
BSD-compatible install options are recognized)."
;;
link)
$ECHO \
"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
Link object files or libraries together to form another library, or to
create an executable program.
LINK-COMMAND is a command using the C compiler that you would use to create
a program from several object files.
The following components of LINK-COMMAND are treated specially:
-all-static do not do any dynamic linking at all
-avoid-version do not add a version suffix if possible
-bindir BINDIR specify path to binaries directory (for systems where
libraries must be found in the PATH setting at runtime)
-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
-export-symbols SYMFILE
try to export only the symbols listed in SYMFILE
-export-symbols-regex REGEX
try to export only the symbols matching REGEX
-LLIBDIR search LIBDIR for required installed libraries
-lNAME OUTPUT-FILE requires the installed library libNAME
-module build a library that can dlopened
-no-fast-install disable the fast-install mode
-no-install link a not-installable executable
-no-undefined declare that a library does not refer to external symbols
-o OUTPUT-FILE create OUTPUT-FILE from the specified objects
-objectlist FILE Use a list of object files found in FILE to specify objects
-precious-files-regex REGEX
don't remove output files matching REGEX
-release RELEASE specify package release information
-rpath LIBDIR the created library will eventually be installed in LIBDIR
-R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
-shared only do dynamic linking of libtool libraries
-shrext SUFFIX override the standard shared library file extension
-static do not do any dynamic linking of uninstalled libtool libraries
-static-libtool-libs
do not do any dynamic linking of libtool libraries
-version-info CURRENT[:REVISION[:AGE]]
specify library version info [each variable defaults to 0]
-weak LIBNAME declare that the target provides the LIBNAME interface
-Wc,FLAG
-Xcompiler FLAG pass linker-specific FLAG directly to the compiler
-Wl,FLAG
-Xlinker FLAG pass linker-specific FLAG directly to the linker
-XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
All other options (arguments beginning with \`-') are ignored.
Every other argument is treated as a filename. Files ending in \`.la' are
treated as uninstalled libtool libraries, other files are standard or library
object files.
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
only library objects (\`.lo' files) may be specified, and \`-rpath' is
required, except when creating a convenience library.
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
using \`ar' and \`ranlib', or on Windows using \`lib'.
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
is created, otherwise an executable program is created."
;;
uninstall)
$ECHO \
"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
Remove libraries from an installation directory.
RM is the name of the program to use to delete files associated with each FILE
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
to RM.
If FILE is a libtool library, all the files associated with it are deleted.
Otherwise, only FILE itself is deleted using RM."
;;
*)
func_fatal_help "invalid operation mode \`$opt_mode'"
;;
esac
echo
$ECHO "Try \`$progname --help' for more information about other modes."
}
# Now that we've collected a possible --mode arg, show help if necessary
if $opt_help; then
if test "$opt_help" = :; then
func_mode_help
else
{
func_help noexit
for opt_mode in compile link execute install finish uninstall clean; do
func_mode_help
done
} | sed -n '1p; 2,$s/^Usage:/ or: /p'
{
func_help noexit
for opt_mode in compile link execute install finish uninstall clean; do
echo
func_mode_help
done
} |
sed '1d
/^When reporting/,/^Report/{
H
d
}
$x
/information about other modes/d
/more detailed .*MODE/d
s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
fi
exit $?
fi
# func_mode_execute arg...
func_mode_execute ()
{
$opt_debug
# The first argument is the command name.
cmd="$nonopt"
test -z "$cmd" && \
func_fatal_help "you must specify a COMMAND"
# Handle -dlopen flags immediately.
for file in $opt_dlopen; do
test -f "$file" \
|| func_fatal_help "\`$file' is not a file"
dir=
case $file in
*.la)
func_resolve_sysroot "$file"
file=$func_resolve_sysroot_result
# Check to see that this really is a libtool archive.
func_lalib_unsafe_p "$file" \
|| func_fatal_help "\`$lib' is not a valid libtool archive"
# Read the libtool library.
dlname=
library_names=
func_source "$file"
# Skip this library if it cannot be dlopened.
if test -z "$dlname"; then
# Warn if it was a shared library.
test -n "$library_names" && \
func_warning "\`$file' was not linked with \`-export-dynamic'"
continue
fi
func_dirname "$file" "" "."
dir="$func_dirname_result"
if test -f "$dir/$objdir/$dlname"; then
func_append dir "/$objdir"
else
if test ! -f "$dir/$dlname"; then
func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
fi
fi
;;
*.lo)
# Just add the directory containing the .lo file.
func_dirname "$file" "" "."
dir="$func_dirname_result"
;;
*)
func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
continue
;;
esac
# Get the absolute pathname.
absdir=`cd "$dir" && pwd`
test -n "$absdir" && dir="$absdir"
# Now add the directory to shlibpath_var.
if eval "test -z \"\$$shlibpath_var\""; then
eval "$shlibpath_var=\"\$dir\""
else
eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
fi
done
# This variable tells wrapper scripts just to set shlibpath_var
# rather than running their programs.
libtool_execute_magic="$magic"
# Check if any of the arguments is a wrapper script.
args=
for file
do
case $file in
-* | *.la | *.lo ) ;;
*)
# Do a test to see if this is really a libtool program.
if func_ltwrapper_script_p "$file"; then
func_source "$file"
# Transform arg to wrapped name.
file="$progdir/$program"
elif func_ltwrapper_executable_p "$file"; then
func_ltwrapper_scriptname "$file"
func_source "$func_ltwrapper_scriptname_result"
# Transform arg to wrapped name.
file="$progdir/$program"
fi
;;
esac
# Quote arguments (to preserve shell metacharacters).
func_append_quoted args "$file"
done
if test "X$opt_dry_run" = Xfalse; then
if test -n "$shlibpath_var"; then
# Export the shlibpath_var.
eval "export $shlibpath_var"
fi
# Restore saved environment variables
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
do
eval "if test \"\${save_$lt_var+set}\" = set; then
$lt_var=\$save_$lt_var; export $lt_var
else
$lt_unset $lt_var
fi"
done
# Now prepare to actually exec the command.
exec_cmd="\$cmd$args"
else
# Display what would be done.
if test -n "$shlibpath_var"; then
eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
echo "export $shlibpath_var"
fi
$ECHO "$cmd$args"
exit $EXIT_SUCCESS
fi
}
test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
# func_mode_finish arg...
func_mode_finish ()
{
$opt_debug
libs=
libdirs=
admincmds=
for opt in "$nonopt" ${1+"$@"}
do
if test -d "$opt"; then
func_append libdirs " $opt"
elif test -f "$opt"; then
if func_lalib_unsafe_p "$opt"; then
func_append libs " $opt"
else
func_warning "\`$opt' is not a valid libtool archive"
fi
else
func_fatal_error "invalid argument \`$opt'"
fi
done
if test -n "$libs"; then
if test -n "$lt_sysroot"; then
sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
else
sysroot_cmd=
fi
# Remove sysroot references
if $opt_dry_run; then
for lib in $libs; do
echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
done
else
tmpdir=`func_mktempdir`
for lib in $libs; do
sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
> $tmpdir/tmp-la
mv -f $tmpdir/tmp-la $lib
done
${RM}r "$tmpdir"
fi
fi
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
for libdir in $libdirs; do
if test -n "$finish_cmds"; then
# Do each command in the finish commands.
func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
'"$cmd"'"'
fi
if test -n "$finish_eval"; then
# Do the single finish_eval.
eval cmds=\"$finish_eval\"
$opt_dry_run || eval "$cmds" || func_append admincmds "
$cmds"
fi
done
fi
# Exit here if they wanted silent mode.
$opt_silent && exit $EXIT_SUCCESS
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
echo "----------------------------------------------------------------------"
echo "Libraries have been installed in:"
for libdir in $libdirs; do
$ECHO " $libdir"
done
echo
echo "If you ever happen to want to link against installed libraries"
echo "in a given directory, LIBDIR, you must either use libtool, and"
echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
echo "flag during linking and do at least one of the following:"
if test -n "$shlibpath_var"; then
echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
echo " during execution"
fi
if test -n "$runpath_var"; then
echo " - add LIBDIR to the \`$runpath_var' environment variable"
echo " during linking"
fi
if test -n "$hardcode_libdir_flag_spec"; then
libdir=LIBDIR
eval flag=\"$hardcode_libdir_flag_spec\"
$ECHO " - use the \`$flag' linker flag"
fi
if test -n "$admincmds"; then
$ECHO " - have your system administrator run these commands:$admincmds"
fi
if test -f /etc/ld.so.conf; then
echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
fi
echo
echo "See any operating system documentation about shared libraries for"
case $host in
solaris2.[6789]|solaris2.1[0-9])
echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
echo "pages."
;;
*)
echo "more information, such as the ld(1) and ld.so(8) manual pages."
;;
esac
echo "----------------------------------------------------------------------"
fi
exit $EXIT_SUCCESS
}
test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
# func_mode_install arg...
func_mode_install ()
{
$opt_debug
# There may be an optional sh(1) argument at the beginning of
# install_prog (especially on Windows NT).
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
# Allow the use of GNU shtool's install command.
case $nonopt in *shtool*) :;; *) false;; esac; then
# Aesthetically quote it.
func_quote_for_eval "$nonopt"
install_prog="$func_quote_for_eval_result "
arg=$1
shift
else
install_prog=
arg=$nonopt
fi
# The real first argument should be the name of the installation program.
# Aesthetically quote it.
func_quote_for_eval "$arg"
func_append install_prog "$func_quote_for_eval_result"
install_shared_prog=$install_prog
case " $install_prog " in
*[\\\ /]cp\ *) install_cp=: ;;
*) install_cp=false ;;
esac
# We need to accept at least all the BSD install flags.
dest=
files=
opts=
prev=
install_type=
isdir=no
stripme=
no_mode=:
for arg
do
arg2=
if test -n "$dest"; then
func_append files " $dest"
dest=$arg
continue
fi
case $arg in
-d) isdir=yes ;;
-f)
if $install_cp; then :; else
prev=$arg
fi
;;
-g | -m | -o)
prev=$arg
;;
-s)
stripme=" -s"
continue
;;
-*)
;;
*)
# If the previous option needed an argument, then skip it.
if test -n "$prev"; then
if test "x$prev" = x-m && test -n "$install_override_mode"; then
arg2=$install_override_mode
no_mode=false
fi
prev=
else
dest=$arg
continue
fi
;;
esac
# Aesthetically quote the argument.
func_quote_for_eval "$arg"
func_append install_prog " $func_quote_for_eval_result"
if test -n "$arg2"; then
func_quote_for_eval "$arg2"
fi
func_append install_shared_prog " $func_quote_for_eval_result"
done
test -z "$install_prog" && \
func_fatal_help "you must specify an install program"
test -n "$prev" && \
func_fatal_help "the \`$prev' option requires an argument"
if test -n "$install_override_mode" && $no_mode; then
if $install_cp; then :; else
func_quote_for_eval "$install_override_mode"
func_append install_shared_prog " -m $func_quote_for_eval_result"
fi
fi
if test -z "$files"; then
if test -z "$dest"; then
func_fatal_help "no file or destination specified"
else
func_fatal_help "you must specify a destination"
fi
fi
# Strip any trailing slash from the destination.
func_stripname '' '/' "$dest"
dest=$func_stripname_result
# Check to see that the destination is a directory.
test -d "$dest" && isdir=yes
if test "$isdir" = yes; then
destdir="$dest"
destname=
else
func_dirname_and_basename "$dest" "" "."
destdir="$func_dirname_result"
destname="$func_basename_result"
# Not a directory, so check to see that there is only one file specified.
set dummy $files; shift
test "$#" -gt 1 && \
func_fatal_help "\`$dest' is not a directory"
fi
case $destdir in
[\\/]* | [A-Za-z]:[\\/]*) ;;
*)
for file in $files; do
case $file in
*.lo) ;;
*)
func_fatal_help "\`$destdir' must be an absolute directory name"
;;
esac
done
;;
esac
# This variable tells wrapper scripts just to set variables rather
# than running their programs.
libtool_install_magic="$magic"
staticlibs=
future_libdirs=
current_libdirs=
for file in $files; do
# Do each installation.
case $file in
*.$libext)
# Do the static libraries later.
func_append staticlibs " $file"
;;
*.la)
func_resolve_sysroot "$file"
file=$func_resolve_sysroot_result
# Check to see that this really is a libtool archive.
func_lalib_unsafe_p "$file" \
|| func_fatal_help "\`$file' is not a valid libtool archive"
library_names=
old_library=
relink_command=
func_source "$file"
# Add the libdir to current_libdirs if it is the destination.
if test "X$destdir" = "X$libdir"; then
case "$current_libdirs " in
*" $libdir "*) ;;
*) func_append current_libdirs " $libdir" ;;
esac
else
# Note the libdir as a future libdir.
case "$future_libdirs " in
*" $libdir "*) ;;
*) func_append future_libdirs " $libdir" ;;
esac
fi
func_dirname "$file" "/" ""
dir="$func_dirname_result"
func_append dir "$objdir"
if test -n "$relink_command"; then
# Determine the prefix the user has applied to our future dir.
inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
# Don't allow the user to place us outside of our expected
# location b/c this prevents finding dependent libraries that
# are installed to the same prefix.
# At present, this check doesn't affect windows .dll's that
# are installed into $libdir/../bin (currently, that works fine)
# but it's something to keep an eye on.
test "$inst_prefix_dir" = "$destdir" && \
func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
if test -n "$inst_prefix_dir"; then
# Stick the inst_prefix_dir data into the link command.
relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
else
relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
fi
func_warning "relinking \`$file'"
func_show_eval "$relink_command" \
'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
fi
# See the names of the shared library.
set dummy $library_names; shift
if test -n "$1"; then
realname="$1"
shift
srcname="$realname"
test -n "$relink_command" && srcname="$realname"T
# Install the shared library and build the symlinks.
func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
'exit $?'
tstripme="$stripme"
case $host_os in
cygwin* | mingw* | pw32* | cegcc*)
case $realname in
*.dll.a)
tstripme=""
;;
esac
;;
esac
if test -n "$tstripme" && test -n "$striplib"; then
func_show_eval "$striplib $destdir/$realname" 'exit $?'
fi
if test "$#" -gt 0; then
# Delete the old symlinks, and create new ones.
# Try `ln -sf' first, because the `ln' binary might depend on
# the symlink we replace! Solaris /bin/ln does not understand -f,
# so we also need to try rm && ln -s.
for linkname
do
test "$linkname" != "$realname" \
&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
done
fi
# Do each command in the postinstall commands.
lib="$destdir/$realname"
func_execute_cmds "$postinstall_cmds" 'exit $?'
fi
# Install the pseudo-library for information purposes.
func_basename "$file"
name="$func_basename_result"
instname="$dir/$name"i
func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
# Maybe install the static library, too.
test -n "$old_library" && func_append staticlibs " $dir/$old_library"
;;
*.lo)
# Install (i.e. copy) a libtool object.
# Figure out destination file name, if it wasn't already specified.
if test -n "$destname"; then
destfile="$destdir/$destname"
else
func_basename "$file"
destfile="$func_basename_result"
destfile="$destdir/$destfile"
fi
# Deduce the name of the destination old-style object file.
case $destfile in
*.lo)
func_lo2o "$destfile"
staticdest=$func_lo2o_result
;;
*.$objext)
staticdest="$destfile"
destfile=
;;
*)
func_fatal_help "cannot copy a libtool object to \`$destfile'"
;;
esac
# Install the libtool object if requested.
test -n "$destfile" && \
func_show_eval "$install_prog $file $destfile" 'exit $?'
# Install the old object if enabled.
if test "$build_old_libs" = yes; then
# Deduce the name of the old-style object file.
func_lo2o "$file"
staticobj=$func_lo2o_result
func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
fi
exit $EXIT_SUCCESS
;;
*)
# Figure out destination file name, if it wasn't already specified.
if test -n "$destname"; then
destfile="$destdir/$destname"
else
func_basename "$file"
destfile="$func_basename_result"
destfile="$destdir/$destfile"
fi
# If the file is missing, and there is a .exe on the end, strip it
# because it is most likely a libtool script we actually want to
# install
stripped_ext=""
case $file in
*.exe)
if test ! -f "$file"; then
func_stripname '' '.exe' "$file"
file=$func_stripname_result
stripped_ext=".exe"
fi
;;
esac
# Do a test to see if this is really a libtool program.
case $host in
*cygwin* | *mingw*)
if func_ltwrapper_executable_p "$file"; then
func_ltwrapper_scriptname "$file"
wrapper=$func_ltwrapper_scriptname_result
else
func_stripname '' '.exe' "$file"
wrapper=$func_stripname_result
fi
;;
*)
wrapper=$file
;;
esac
if func_ltwrapper_script_p "$wrapper"; then
notinst_deplibs=
relink_command=
func_source "$wrapper"
# Check the variables that should have been set.
test -z "$generated_by_libtool_version" && \
func_fatal_error "invalid libtool wrapper script \`$wrapper'"
finalize=yes
for lib in $notinst_deplibs; do
# Check to see that each library is installed.
libdir=
if test -f "$lib"; then
func_source "$lib"
fi
libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
if test -n "$libdir" && test ! -f "$libfile"; then
func_warning "\`$lib' has not been installed in \`$libdir'"
finalize=no
fi
done
relink_command=
func_source "$wrapper"
outputname=
if test "$fast_install" = no && test -n "$relink_command"; then
$opt_dry_run || {
if test "$finalize" = yes; then
tmpdir=`func_mktempdir`
func_basename "$file$stripped_ext"
file="$func_basename_result"
outputname="$tmpdir/$file"
# Replace the output file specification.
relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
$opt_silent || {
func_quote_for_expand "$relink_command"
eval "func_echo $func_quote_for_expand_result"
}
if eval "$relink_command"; then :
else
func_error "error: relink \`$file' with the above command before installing it"
$opt_dry_run || ${RM}r "$tmpdir"
continue
fi
file="$outputname"
else
func_warning "cannot relink \`$file'"
fi
}
else
# Install the binary that we compiled earlier.
file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
fi
fi
# remove .exe since cygwin /usr/bin/install will append another
# one anyway
case $install_prog,$host in
*/usr/bin/install*,*cygwin*)
case $file:$destfile in
*.exe:*.exe)
# this is ok
;;
*.exe:*)
destfile=$destfile.exe
;;
*:*.exe)
func_stripname '' '.exe' "$destfile"
destfile=$func_stripname_result
;;
esac
;;
esac
func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
$opt_dry_run || if test -n "$outputname"; then
${RM}r "$tmpdir"
fi
;;
esac
done
for file in $staticlibs; do
func_basename "$file"
name="$func_basename_result"
# Set up the ranlib parameters.
oldlib="$destdir/$name"
func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
tool_oldlib=$func_to_tool_file_result
func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
if test -n "$stripme" && test -n "$old_striplib"; then
func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
fi
# Do each command in the postinstall commands.
func_execute_cmds "$old_postinstall_cmds" 'exit $?'
done
test -n "$future_libdirs" && \
func_warning "remember to run \`$progname --finish$future_libdirs'"
if test -n "$current_libdirs"; then
# Maybe just do a dry run.
$opt_dry_run && current_libdirs=" -n$current_libdirs"
exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
else
exit $EXIT_SUCCESS
fi
}
test "$opt_mode" = install && func_mode_install ${1+"$@"}
# func_generate_dlsyms outputname originator pic_p
# Extract symbols from dlprefiles and create ${outputname}S.o with
# a dlpreopen symbol table.
func_generate_dlsyms ()
{
$opt_debug
my_outputname="$1"
my_originator="$2"
my_pic_p="${3-no}"
my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
my_dlsyms=
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
if test -n "$NM" && test -n "$global_symbol_pipe"; then
my_dlsyms="${my_outputname}S.c"
else
func_error "not configured to extract global symbols from dlpreopened files"
fi
fi
if test -n "$my_dlsyms"; then
case $my_dlsyms in
"") ;;
*.c)
# Discover the nlist of each of the dlfiles.
nlist="$output_objdir/${my_outputname}.nm"
func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
# Parse the name list into a source file.
func_verbose "creating $output_objdir/$my_dlsyms"
$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
#ifdef __cplusplus
extern \"C\" {
#endif
#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
#endif
/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
/* DATA imports from DLLs on WIN32 con't be const, because runtime
relocations are performed -- see ld's documentation on pseudo-relocs. */
# define LT_DLSYM_CONST
#elif defined(__osf__)
/* This system does not cope well with relocations in const data. */
# define LT_DLSYM_CONST
#else
# define LT_DLSYM_CONST const
#endif
/* External symbol declarations for the compiler. */\
"
if test "$dlself" = yes; then
func_verbose "generating symbol list for \`$output'"
$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
# Add our own program objects to the symbol list.
progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
for progfile in $progfiles; do
func_to_tool_file "$progfile" func_convert_file_msys_to_w32
func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
$opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
done
if test -n "$exclude_expsyms"; then
$opt_dry_run || {
eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
eval '$MV "$nlist"T "$nlist"'
}
fi
if test -n "$export_symbols_regex"; then
$opt_dry_run || {
eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
eval '$MV "$nlist"T "$nlist"'
}
fi
# Prepare the list of exported symbols
if test -z "$export_symbols"; then
export_symbols="$output_objdir/$outputname.exp"
$opt_dry_run || {
$RM $export_symbols
eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
case $host in
*cygwin* | *mingw* | *cegcc* )
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
;;
esac
}
else
$opt_dry_run || {
eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
eval '$MV "$nlist"T "$nlist"'
case $host in
*cygwin* | *mingw* | *cegcc* )
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
;;
esac
}
fi
fi
for dlprefile in $dlprefiles; do
func_verbose "extracting global C symbols from \`$dlprefile'"
func_basename "$dlprefile"
name="$func_basename_result"
case $host in
*cygwin* | *mingw* | *cegcc* )
# if an import library, we need to obtain dlname
if func_win32_import_lib_p "$dlprefile"; then
func_tr_sh "$dlprefile"
eval "curr_lafile=\$libfile_$func_tr_sh_result"
dlprefile_dlbasename=""
if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
# Use subshell, to avoid clobbering current variable values
dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
if test -n "$dlprefile_dlname" ; then
func_basename "$dlprefile_dlname"
dlprefile_dlbasename="$func_basename_result"
else
# no lafile. user explicitly requested -dlpreopen <import library>.
$sharedlib_from_linklib_cmd "$dlprefile"
dlprefile_dlbasename=$sharedlib_from_linklib_result
fi
fi
$opt_dry_run || {
if test -n "$dlprefile_dlbasename" ; then
eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
else
func_warning "Could not compute DLL name from $name"
eval '$ECHO ": $name " >> "$nlist"'
fi
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
$SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
}
else # not an import lib
$opt_dry_run || {
eval '$ECHO ": $name " >> "$nlist"'
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
}
fi
;;
*)
$opt_dry_run || {
eval '$ECHO ": $name " >> "$nlist"'
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
}
;;
esac
done
$opt_dry_run || {
# Make sure we have at least an empty file.
test -f "$nlist" || : > "$nlist"
if test -n "$exclude_expsyms"; then
$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
$MV "$nlist"T "$nlist"
fi
# Try sorting and uniquifying the output.
if $GREP -v "^: " < "$nlist" |
if sort -k 3 </dev/null >/dev/null 2>&1; then
sort -k 3
else
sort +2
fi |
uniq > "$nlist"S; then
:
else
$GREP -v "^: " < "$nlist" > "$nlist"S
fi
if test -f "$nlist"S; then
eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
else
echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
fi
echo >> "$output_objdir/$my_dlsyms" "\
/* The mapping between symbol names and symbols. */
typedef struct {
const char *name;
void *address;
} lt_dlsymlist;
extern LT_DLSYM_CONST lt_dlsymlist
lt_${my_prefix}_LTX_preloaded_symbols[];
LT_DLSYM_CONST lt_dlsymlist
lt_${my_prefix}_LTX_preloaded_symbols[] =
{\
{ \"$my_originator\", (void *) 0 },"
case $need_lib_prefix in
no)
eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
;;
*)
eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
;;
esac
echo >> "$output_objdir/$my_dlsyms" "\
{0, (void *) 0}
};
/* This works around a problem in FreeBSD linker */
#ifdef FREEBSD_WORKAROUND
static const void *lt_preloaded_setup() {
return lt_${my_prefix}_LTX_preloaded_symbols;
}
#endif
#ifdef __cplusplus
}
#endif\
"
} # !$opt_dry_run
pic_flag_for_symtable=
case "$compile_command " in
*" -static "*) ;;
*)
case $host in
# compiling the symbol table file with pic_flag works around
# a FreeBSD bug that causes programs to crash when -lm is
# linked before any other PIC object. But we must not use
# pic_flag when linking with -static. The problem exists in
# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
*-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
*-*-hpux*)
pic_flag_for_symtable=" $pic_flag" ;;
*)
if test "X$my_pic_p" != Xno; then
pic_flag_for_symtable=" $pic_flag"
fi
;;
esac
;;
esac
symtab_cflags=
for arg in $LTCFLAGS; do
case $arg in
-pie | -fpie | -fPIE) ;;
*) func_append symtab_cflags " $arg" ;;
esac
done
# Now compile the dynamic symbol file.
func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
# Clean up the generated files.
func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
# Transform the symbol file into the correct name.
symfileobj="$output_objdir/${my_outputname}S.$objext"
case $host in
*cygwin* | *mingw* | *cegcc* )
if test -f "$output_objdir/$my_outputname.def"; then
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
else
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
fi
;;
*)
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
;;
esac
;;
*)
func_fatal_error "unknown suffix for \`$my_dlsyms'"
;;
esac
else
# We keep going just in case the user didn't refer to
# lt_preloaded_symbols. The linker will fail if global_symbol_pipe
# really was required.
# Nullify the symbol file.
compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
fi
}
# func_win32_libid arg
# return the library type of file 'arg'
#
# Need a lot of goo to handle *both* DLLs and import libs
# Has to be a shell function in order to 'eat' the argument
# that is supplied when $file_magic_command is called.
# Despite the name, also deal with 64 bit binaries.
func_win32_libid ()
{
$opt_debug
win32_libid_type="unknown"
win32_fileres=`file -L $1 2>/dev/null`
case $win32_fileres in
*ar\ archive\ import\ library*) # definitely import
win32_libid_type="x86 archive import"
;;
*ar\ archive*) # could be an import, or static
# Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
$EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
func_to_tool_file "$1" func_convert_file_msys_to_w32
win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
$SED -n -e '
1,100{
/ I /{
s,.*,import,
p
q
}
}'`
case $win32_nmres in
import*) win32_libid_type="x86 archive import";;
*) win32_libid_type="x86 archive static";;
esac
fi
;;
*DLL*)
win32_libid_type="x86 DLL"
;;
*executable*) # but shell scripts are "executable" too...
case $win32_fileres in
*MS\ Windows\ PE\ Intel*)
win32_libid_type="x86 DLL"
;;
esac
;;
esac
$ECHO "$win32_libid_type"
}
# func_cygming_dll_for_implib ARG
#
# Platform-specific function to extract the
# name of the DLL associated with the specified
# import library ARG.
# Invoked by eval'ing the libtool variable
# $sharedlib_from_linklib_cmd
# Result is available in the variable
# $sharedlib_from_linklib_result
func_cygming_dll_for_implib ()
{
$opt_debug
sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
}
# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
#
# The is the core of a fallback implementation of a
# platform-specific function to extract the name of the
# DLL associated with the specified import library LIBNAME.
#
# SECTION_NAME is either .idata$6 or .idata$7, depending
# on the platform and compiler that created the implib.
#
# Echos the name of the DLL associated with the
# specified import library.
func_cygming_dll_for_implib_fallback_core ()
{
$opt_debug
match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
$OBJDUMP -s --section "$1" "$2" 2>/dev/null |
$SED '/^Contents of section '"$match_literal"':/{
# Place marker at beginning of archive member dllname section
s/.*/====MARK====/
p
d
}
# These lines can sometimes be longer than 43 characters, but
# are always uninteresting
/:[ ]*file format pe[i]\{,1\}-/d
/^In archive [^:]*:/d
# Ensure marker is printed
/^====MARK====/p
# Remove all lines with less than 43 characters
/^.\{43\}/!d
# From remaining lines, remove first 43 characters
s/^.\{43\}//' |
$SED -n '
# Join marker and all lines until next marker into a single line
/^====MARK====/ b para
H
$ b para
b
:para
x
s/\n//g
# Remove the marker
s/^====MARK====//
# Remove trailing dots and whitespace
s/[\. \t]*$//
# Print
/./p' |
# we now have a list, one entry per line, of the stringified
# contents of the appropriate section of all members of the
# archive which possess that section. Heuristic: eliminate
# all those which have a first or second character that is
# a '.' (that is, objdump's representation of an unprintable
# character.) This should work for all archives with less than
# 0x302f exports -- but will fail for DLLs whose name actually
# begins with a literal '.' or a single character followed by
# a '.'.
#
# Of those that remain, print the first one.
$SED -e '/^\./d;/^.\./d;q'
}
# func_cygming_gnu_implib_p ARG
# This predicate returns with zero status (TRUE) if
# ARG is a GNU/binutils-style import library. Returns
# with nonzero status (FALSE) otherwise.
func_cygming_gnu_implib_p ()
{
$opt_debug
func_to_tool_file "$1" func_convert_file_msys_to_w32
func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
test -n "$func_cygming_gnu_implib_tmp"
}
# func_cygming_ms_implib_p ARG
# This predicate returns with zero status (TRUE) if
# ARG is an MS-style import library. Returns
# with nonzero status (FALSE) otherwise.
func_cygming_ms_implib_p ()
{
$opt_debug
func_to_tool_file "$1" func_convert_file_msys_to_w32
func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
test -n "$func_cygming_ms_implib_tmp"
}
# func_cygming_dll_for_implib_fallback ARG
# Platform-specific function to extract the
# name of the DLL associated with the specified
# import library ARG.
#
# This fallback implementation is for use when $DLLTOOL
# does not support the --identify-strict option.
# Invoked by eval'ing the libtool variable
# $sharedlib_from_linklib_cmd
# Result is available in the variable
# $sharedlib_from_linklib_result
func_cygming_dll_for_implib_fallback ()
{
$opt_debug
if func_cygming_gnu_implib_p "$1" ; then
# binutils import library
sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
elif func_cygming_ms_implib_p "$1" ; then
# ms-generated import library
sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
else
# unknown
sharedlib_from_linklib_result=""
fi
}
# func_extract_an_archive dir oldlib
func_extract_an_archive ()
{
$opt_debug
f_ex_an_ar_dir="$1"; shift
f_ex_an_ar_oldlib="$1"
if test "$lock_old_archive_extraction" = yes; then
lockfile=$f_ex_an_ar_oldlib.lock
until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
func_echo "Waiting for $lockfile to be removed"
sleep 2
done
fi
func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
'stat=$?; rm -f "$lockfile"; exit $stat'
if test "$lock_old_archive_extraction" = yes; then
$opt_dry_run || rm -f "$lockfile"
fi
if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
:
else
func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
fi
}
# func_extract_archives gentop oldlib ...
func_extract_archives ()
{
$opt_debug
my_gentop="$1"; shift
my_oldlibs=${1+"$@"}
my_oldobjs=""
my_xlib=""
my_xabs=""
my_xdir=""
for my_xlib in $my_oldlibs; do
# Extract the objects.
case $my_xlib in
[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
*) my_xabs=`pwd`"/$my_xlib" ;;
esac
func_basename "$my_xlib"
my_xlib="$func_basename_result"
my_xlib_u=$my_xlib
while :; do
case " $extracted_archives " in
*" $my_xlib_u "*)
func_arith $extracted_serial + 1
extracted_serial=$func_arith_result
my_xlib_u=lt$extracted_serial-$my_xlib ;;
*) break ;;
esac
done
extracted_archives="$extracted_archives $my_xlib_u"
my_xdir="$my_gentop/$my_xlib_u"
func_mkdir_p "$my_xdir"
case $host in
*-darwin*)
func_verbose "Extracting $my_xabs"
# Do not bother doing anything if just a dry run
$opt_dry_run || {
darwin_orig_dir=`pwd`
cd $my_xdir || exit $?
darwin_archive=$my_xabs
darwin_curdir=`pwd`
darwin_base_archive=`basename "$darwin_archive"`
darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
if test -n "$darwin_arches"; then
darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
darwin_arch=
func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
for darwin_arch in $darwin_arches ; do
func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
func_extract_an_archive "`pwd`" "${darwin_base_archive}"
cd "$darwin_curdir"
$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
done # $darwin_arches
## Okay now we've a bunch of thin objects, gotta fatten them up :)
darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
darwin_file=
darwin_files=
for darwin_file in $darwin_filelist; do
darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
$LIPO -create -output "$darwin_file" $darwin_files
done # $darwin_filelist
$RM -rf unfat-$$
cd "$darwin_orig_dir"
else
cd $darwin_orig_dir
func_extract_an_archive "$my_xdir" "$my_xabs"
fi # $darwin_arches
} # !$opt_dry_run
;;
*)
func_extract_an_archive "$my_xdir" "$my_xabs"
;;
esac
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
done
func_extract_archives_result="$my_oldobjs"
}
# func_emit_wrapper [arg=no]
#
# Emit a libtool wrapper script on stdout.
# Don't directly open a file because we may want to
# incorporate the script contents within a cygwin/mingw
# wrapper executable. Must ONLY be called from within
# func_mode_link because it depends on a number of variables
# set therein.
#
# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
# variable will take. If 'yes', then the emitted script
# will assume that the directory in which it is stored is
# the $objdir directory. This is a cygwin/mingw-specific
# behavior.
func_emit_wrapper ()
{
func_emit_wrapper_arg1=${1-no}
$ECHO "\
#! $SHELL
# $output - temporary wrapper script for $objdir/$outputname
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
#
# The $output program cannot be directly executed until all the libtool
# libraries that it depends on are installed.
#
# This wrapper script should never be moved out of the build directory.
# If it is, it will not operate correctly.
# Sed substitution that helps us do robust quoting. It backslashifies
# metacharacters that are still active within double-quoted strings.
sed_quote_subst='$sed_quote_subst'
# Be Bourne compatible
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
emulate sh
NULLCMD=:
# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
# is contrary to our usage. Disable this feature.
alias -g '\${1+\"\$@\"}'='\"\$@\"'
setopt NO_GLOB_SUBST
else
case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
fi
BIN_SH=xpg4; export BIN_SH # for Tru64
DUALCASE=1; export DUALCASE # for MKS sh
# The HP-UX ksh and POSIX shell print the target directory to stdout
# if CDPATH is set.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
relink_command=\"$relink_command\"
# This environment variable determines our operation mode.
if test \"\$libtool_install_magic\" = \"$magic\"; then
# install mode needs the following variables:
generated_by_libtool_version='$macro_version'
notinst_deplibs='$notinst_deplibs'
else
# When we are sourced in execute mode, \$file and \$ECHO are already set.
if test \"\$libtool_execute_magic\" != \"$magic\"; then
file=\"\$0\""
qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
$ECHO "\
# A function that is used when there is no print builtin or printf.
func_fallback_echo ()
{
eval 'cat <<_LTECHO_EOF
\$1
_LTECHO_EOF'
}
ECHO=\"$qECHO\"
fi
# Very basic option parsing. These options are (a) specific to
# the libtool wrapper, (b) are identical between the wrapper
# /script/ and the wrapper /executable/ which is used only on
# windows platforms, and (c) all begin with the string "--lt-"
# (application programs are unlikely to have options which match
# this pattern).
#
# There are only two supported options: --lt-debug and
# --lt-dump-script. There is, deliberately, no --lt-help.
#
# The first argument to this parsing function should be the
# script's $0 value, followed by "$@".
lt_option_debug=
func_parse_lt_options ()
{
lt_script_arg0=\$0
shift
for lt_opt
do
case \"\$lt_opt\" in
--lt-debug) lt_option_debug=1 ;;
--lt-dump-script)
lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
cat \"\$lt_dump_D/\$lt_dump_F\"
exit 0
;;
--lt-*)
\$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
exit 1
;;
esac
done
# Print the debug banner immediately:
if test -n \"\$lt_option_debug\"; then
echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
fi
}
# Used when --lt-debug. Prints its arguments to stdout
# (redirection is the responsibility of the caller)
func_lt_dump_args ()
{
lt_dump_args_N=1;
for lt_arg
do
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
done
}
# Core function for launching the target application
func_exec_program_core ()
{
"
case $host in
# Backslashes separate directories on plain windows
*-*-mingw | *-*-os2* | *-cegcc*)
$ECHO "\
if test -n \"\$lt_option_debug\"; then
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
func_lt_dump_args \${1+\"\$@\"} 1>&2
fi
exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
"
;;
*)
$ECHO "\
if test -n \"\$lt_option_debug\"; then
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
func_lt_dump_args \${1+\"\$@\"} 1>&2
fi
exec \"\$progdir/\$program\" \${1+\"\$@\"}
"
;;
esac
$ECHO "\
\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
exit 1
}
# A function to encapsulate launching the target application
# Strips options in the --lt-* namespace from \$@ and
# launches target application with the remaining arguments.
func_exec_program ()
{
case \" \$* \" in
*\\ --lt-*)
for lt_wr_arg
do
case \$lt_wr_arg in
--lt-*) ;;
*) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
esac
shift
done ;;
esac
func_exec_program_core \${1+\"\$@\"}
}
# Parse options
func_parse_lt_options \"\$0\" \${1+\"\$@\"}
# Find the directory that this script lives in.
thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
# Follow symbolic links until we get to the real thisdir.
file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
while test -n \"\$file\"; do
destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
# If there was a directory component, then change thisdir.
if test \"x\$destdir\" != \"x\$file\"; then
case \"\$destdir\" in
[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
*) thisdir=\"\$thisdir/\$destdir\" ;;
esac
fi
file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
done
# Usually 'no', except on cygwin/mingw when embedded into
# the cwrapper.
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
# special case for '.'
if test \"\$thisdir\" = \".\"; then
thisdir=\`pwd\`
fi
# remove .libs from thisdir
case \"\$thisdir\" in
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
$objdir ) thisdir=. ;;
esac
fi
# Try to get the absolute directory name.
absdir=\`cd \"\$thisdir\" && pwd\`
test -n \"\$absdir\" && thisdir=\"\$absdir\"
"
if test "$fast_install" = yes; then
$ECHO "\
program=lt-'$outputname'$exeext
progdir=\"\$thisdir/$objdir\"
if test ! -f \"\$progdir/\$program\" ||
{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
test \"X\$file\" != \"X\$progdir/\$program\"; }; then
file=\"\$\$-\$program\"
if test ! -d \"\$progdir\"; then
$MKDIR \"\$progdir\"
else
$RM \"\$progdir/\$file\"
fi"
$ECHO "\
# relink executable if necessary
if test -n \"\$relink_command\"; then
if relink_command_output=\`eval \$relink_command 2>&1\`; then :
else
$ECHO \"\$relink_command_output\" >&2
$RM \"\$progdir/\$file\"
exit 1
fi
fi
$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
{ $RM \"\$progdir/\$program\";
$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
$RM \"\$progdir/\$file\"
fi"
else
$ECHO "\
program='$outputname'
progdir=\"\$thisdir/$objdir\"
"
fi
$ECHO "\
if test -f \"\$progdir/\$program\"; then"
# fixup the dll searchpath if we need to.
#
# Fix the DLL searchpath if we need to. Do this before prepending
# to shlibpath, because on Windows, both are PATH and uninstalled
# libraries must come first.
if test -n "$dllsearchpath"; then
$ECHO "\
# Add the dll search path components to the executable PATH
PATH=$dllsearchpath:\$PATH
"
fi
# Export our shlibpath_var if we have one.
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
$ECHO "\
# Add our own library path to $shlibpath_var
$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
# Some systems cannot cope with colon-terminated $shlibpath_var
# The second colon is a workaround for a bug in BeOS R4 sed
$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
export $shlibpath_var
"
fi
$ECHO "\
if test \"\$libtool_execute_magic\" != \"$magic\"; then
# Run the actual program with our arguments.
func_exec_program \${1+\"\$@\"}
fi
else
# The program doesn't exist.
\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
exit 1
fi
fi\
"
}
# func_emit_cwrapperexe_src
# emit the source code for a wrapper executable on stdout
# Must ONLY be called from within func_mode_link because
# it depends on a number of variable set therein.
func_emit_cwrapperexe_src ()
{
cat <<EOF
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
The $output program cannot be directly executed until all the libtool
libraries that it depends on are installed.
This wrapper executable should never be moved out of the build directory.
If it is, it will not operate correctly.
*/
EOF
cat <<"EOF"
#ifdef _MSC_VER
# define _CRT_SECURE_NO_DEPRECATE 1
#endif
#include <stdio.h>
#include <stdlib.h>
#ifdef _MSC_VER
# include <direct.h>
# include <process.h>
# include <io.h>
#else
# include <unistd.h>
# include <stdint.h>
# ifdef __CYGWIN__
# include <io.h>
# endif
#endif
#include <malloc.h>
#include <stdarg.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
/* declarations of non-ANSI functions */
#if defined(__MINGW32__)
# ifdef __STRICT_ANSI__
int _putenv (const char *);
# endif
#elif defined(__CYGWIN__)
# ifdef __STRICT_ANSI__
char *realpath (const char *, char *);
int putenv (char *);
int setenv (const char *, const char *, int);
# endif
/* #elif defined (other platforms) ... */
#endif
/* portability defines, excluding path handling macros */
#if defined(_MSC_VER)
# define setmode _setmode
# define stat _stat
# define chmod _chmod
# define getcwd _getcwd
# define putenv _putenv
# define S_IXUSR _S_IEXEC
# ifndef _INTPTR_T_DEFINED
# define _INTPTR_T_DEFINED
# define intptr_t int
# endif
#elif defined(__MINGW32__)
# define setmode _setmode
# define stat _stat
# define chmod _chmod
# define getcwd _getcwd
# define putenv _putenv
#elif defined(__CYGWIN__)
# define HAVE_SETENV
# define FOPEN_WB "wb"
/* #elif defined (other platforms) ... */
#endif
#if defined(PATH_MAX)
# define LT_PATHMAX PATH_MAX
#elif defined(MAXPATHLEN)
# define LT_PATHMAX MAXPATHLEN
#else
# define LT_PATHMAX 1024
#endif
#ifndef S_IXOTH
# define S_IXOTH 0
#endif
#ifndef S_IXGRP
# define S_IXGRP 0
#endif
/* path handling portability macros */
#ifndef DIR_SEPARATOR
# define DIR_SEPARATOR '/'
# define PATH_SEPARATOR ':'
#endif
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
defined (__OS2__)
# define HAVE_DOS_BASED_FILE_SYSTEM
# define FOPEN_WB "wb"
# ifndef DIR_SEPARATOR_2
# define DIR_SEPARATOR_2 '\\'
# endif
# ifndef PATH_SEPARATOR_2
# define PATH_SEPARATOR_2 ';'
# endif
#endif
#ifndef DIR_SEPARATOR_2
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
#else /* DIR_SEPARATOR_2 */
# define IS_DIR_SEPARATOR(ch) \
(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
#endif /* DIR_SEPARATOR_2 */
#ifndef PATH_SEPARATOR_2
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
#else /* PATH_SEPARATOR_2 */
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
#endif /* PATH_SEPARATOR_2 */
#ifndef FOPEN_WB
# define FOPEN_WB "w"
#endif
#ifndef _O_BINARY
# define _O_BINARY 0
#endif
#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
#define XFREE(stale) do { \
if (stale) { free ((void *) stale); stale = 0; } \
} while (0)
#if defined(LT_DEBUGWRAPPER)
static int lt_debug = 1;
#else
static int lt_debug = 0;
#endif
const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
void *xmalloc (size_t num);
char *xstrdup (const char *string);
const char *base_name (const char *name);
char *find_executable (const char *wrapper);
char *chase_symlinks (const char *pathspec);
int make_executable (const char *path);
int check_executable (const char *path);
char *strendzap (char *str, const char *pat);
void lt_debugprintf (const char *file, int line, const char *fmt, ...);
void lt_fatal (const char *file, int line, const char *message, ...);
static const char *nonnull (const char *s);
static const char *nonempty (const char *s);
void lt_setenv (const char *name, const char *value);
char *lt_extend_str (const char *orig_value, const char *add, int to_end);
void lt_update_exe_path (const char *name, const char *value);
void lt_update_lib_path (const char *name, const char *value);
char **prepare_spawn (char **argv);
void lt_dump_script (FILE *f);
EOF
cat <<EOF
volatile const char * MAGIC_EXE = "$magic_exe";
const char * LIB_PATH_VARNAME = "$shlibpath_var";
EOF
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
func_to_host_path "$temp_rpath"
cat <<EOF
const char * LIB_PATH_VALUE = "$func_to_host_path_result";
EOF
else
cat <<"EOF"
const char * LIB_PATH_VALUE = "";
EOF
fi
if test -n "$dllsearchpath"; then
func_to_host_path "$dllsearchpath:"
cat <<EOF
const char * EXE_PATH_VARNAME = "PATH";
const char * EXE_PATH_VALUE = "$func_to_host_path_result";
EOF
else
cat <<"EOF"
const char * EXE_PATH_VARNAME = "";
const char * EXE_PATH_VALUE = "";
EOF
fi
if test "$fast_install" = yes; then
cat <<EOF
const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
EOF
else
cat <<EOF
const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
EOF
fi
cat <<"EOF"
#define LTWRAPPER_OPTION_PREFIX "--lt-"
static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
int
main (int argc, char *argv[])
{
char **newargz;
int newargc;
char *tmp_pathspec;
char *actual_cwrapper_path;
char *actual_cwrapper_name;
char *target_name;
char *lt_argv_zero;
intptr_t rval = 127;
int i;
program_name = (char *) xstrdup (base_name (argv[0]));
newargz = XMALLOC (char *, argc + 1);
/* very simple arg parsing; don't want to rely on getopt
* also, copy all non cwrapper options to newargz, except
* argz[0], which is handled differently
*/
newargc=0;
for (i = 1; i < argc; i++)
{
if (strcmp (argv[i], dumpscript_opt) == 0)
{
EOF
case "$host" in
*mingw* | *cygwin* )
# make stdout use "unix" line endings
echo " setmode(1,_O_BINARY);"
;;
esac
cat <<"EOF"
lt_dump_script (stdout);
return 0;
}
if (strcmp (argv[i], debug_opt) == 0)
{
lt_debug = 1;
continue;
}
if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
{
/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
namespace, but it is not one of the ones we know about and
have already dealt with, above (inluding dump-script), then
report an error. Otherwise, targets might begin to believe
they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
namespace. The first time any user complains about this, we'll
need to make LTWRAPPER_OPTION_PREFIX a configure-time option
or a configure.ac-settable value.
*/
lt_fatal (__FILE__, __LINE__,
"unrecognized %s option: '%s'",
ltwrapper_option_prefix, argv[i]);
}
/* otherwise ... */
newargz[++newargc] = xstrdup (argv[i]);
}
newargz[++newargc] = NULL;
EOF
cat <<EOF
/* The GNU banner must be the first non-error debug message */
lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
EOF
cat <<"EOF"
lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
tmp_pathspec = find_executable (argv[0]);
if (tmp_pathspec == NULL)
lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
lt_debugprintf (__FILE__, __LINE__,
"(main) found exe (before symlink chase) at: %s\n",
tmp_pathspec);
actual_cwrapper_path = chase_symlinks (tmp_pathspec);
lt_debugprintf (__FILE__, __LINE__,
"(main) found exe (after symlink chase) at: %s\n",
actual_cwrapper_path);
XFREE (tmp_pathspec);
actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
strendzap (actual_cwrapper_path, actual_cwrapper_name);
/* wrapper name transforms */
strendzap (actual_cwrapper_name, ".exe");
tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
XFREE (actual_cwrapper_name);
actual_cwrapper_name = tmp_pathspec;
tmp_pathspec = 0;
/* target_name transforms -- use actual target program name; might have lt- prefix */
target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
strendzap (target_name, ".exe");
tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
XFREE (target_name);
target_name = tmp_pathspec;
tmp_pathspec = 0;
lt_debugprintf (__FILE__, __LINE__,
"(main) libtool target name: %s\n",
target_name);
EOF
cat <<EOF
newargz[0] =
XMALLOC (char, (strlen (actual_cwrapper_path) +
strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
strcpy (newargz[0], actual_cwrapper_path);
strcat (newargz[0], "$objdir");
strcat (newargz[0], "/");
EOF
cat <<"EOF"
/* stop here, and copy so we don't have to do this twice */
tmp_pathspec = xstrdup (newargz[0]);
/* do NOT want the lt- prefix here, so use actual_cwrapper_name */
strcat (newargz[0], actual_cwrapper_name);
/* DO want the lt- prefix here if it exists, so use target_name */
lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
XFREE (tmp_pathspec);
tmp_pathspec = NULL;
EOF
case $host_os in
mingw*)
cat <<"EOF"
{
char* p;
while ((p = strchr (newargz[0], '\\')) != NULL)
{
*p = '/';
}
while ((p = strchr (lt_argv_zero, '\\')) != NULL)
{
*p = '/';
}
}
EOF
;;
esac
cat <<"EOF"
XFREE (target_name);
XFREE (actual_cwrapper_path);
XFREE (actual_cwrapper_name);
lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
lt_setenv ("DUALCASE", "1"); /* for MSK sh */
/* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
because on Windows, both *_VARNAMEs are PATH but uninstalled
libraries must come first. */
lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
nonnull (lt_argv_zero));
for (i = 0; i < newargc; i++)
{
lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
i, nonnull (newargz[i]));
}
EOF
case $host_os in
mingw*)
cat <<"EOF"
/* execv doesn't actually work on mingw as expected on unix */
newargz = prepare_spawn (newargz);
rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
if (rval == -1)
{
/* failed to start process */
lt_debugprintf (__FILE__, __LINE__,
"(main) failed to launch target \"%s\": %s\n",
lt_argv_zero, nonnull (strerror (errno)));
return 127;
}
return rval;
EOF
;;
*)
cat <<"EOF"
execv (lt_argv_zero, newargz);
return rval; /* =127, but avoids unused variable warning */
EOF
;;
esac
cat <<"EOF"
}
void *
xmalloc (size_t num)
{
void *p = (void *) malloc (num);
if (!p)
lt_fatal (__FILE__, __LINE__, "memory exhausted");
return p;
}
char *
xstrdup (const char *string)
{
return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
string) : NULL;
}
const char *
base_name (const char *name)
{
const char *base;
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
/* Skip over the disk name in MSDOS pathnames. */
if (isalpha ((unsigned char) name[0]) && name[1] == ':')
name += 2;
#endif
for (base = name; *name; name++)
if (IS_DIR_SEPARATOR (*name))
base = name + 1;
return base;
}
int
check_executable (const char *path)
{
struct stat st;
lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
nonempty (path));
if ((!path) || (!*path))
return 0;
if ((stat (path, &st) >= 0)
&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
return 1;
else
return 0;
}
int
make_executable (const char *path)
{
int rval = 0;
struct stat st;
lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
nonempty (path));
if ((!path) || (!*path))
return 0;
if (stat (path, &st) >= 0)
{
rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
}
return rval;
}
/* Searches for the full path of the wrapper. Returns
newly allocated full path name if found, NULL otherwise
Does not chase symlinks, even on platforms that support them.
*/
char *
find_executable (const char *wrapper)
{
int has_slash = 0;
const char *p;
const char *p_next;
/* static buffer for getcwd */
char tmp[LT_PATHMAX + 1];
int tmp_len;
char *concat_name;
lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
nonempty (wrapper));
if ((wrapper == NULL) || (*wrapper == '\0'))
return NULL;
/* Absolute path? */
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
{
concat_name = xstrdup (wrapper);
if (check_executable (concat_name))
return concat_name;
XFREE (concat_name);
}
else
{
#endif
if (IS_DIR_SEPARATOR (wrapper[0]))
{
concat_name = xstrdup (wrapper);
if (check_executable (concat_name))
return concat_name;
XFREE (concat_name);
}
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
}
#endif
for (p = wrapper; *p; p++)
if (*p == '/')
{
has_slash = 1;
break;
}
if (!has_slash)
{
/* no slashes; search PATH */
const char *path = getenv ("PATH");
if (path != NULL)
{
for (p = path; *p; p = p_next)
{
const char *q;
size_t p_len;
for (q = p; *q; q++)
if (IS_PATH_SEPARATOR (*q))
break;
p_len = q - p;
p_next = (*q == '\0' ? q : q + 1);
if (p_len == 0)
{
/* empty path: current directory */
if (getcwd (tmp, LT_PATHMAX) == NULL)
lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
nonnull (strerror (errno)));
tmp_len = strlen (tmp);
concat_name =
XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
memcpy (concat_name, tmp, tmp_len);
concat_name[tmp_len] = '/';
strcpy (concat_name + tmp_len + 1, wrapper);
}
else
{
concat_name =
XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
memcpy (concat_name, p, p_len);
concat_name[p_len] = '/';
strcpy (concat_name + p_len + 1, wrapper);
}
if (check_executable (concat_name))
return concat_name;
XFREE (concat_name);
}
}
/* not found in PATH; assume curdir */
}
/* Relative path | not found in path: prepend cwd */
if (getcwd (tmp, LT_PATHMAX) == NULL)
lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
nonnull (strerror (errno)));
tmp_len = strlen (tmp);
concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
memcpy (concat_name, tmp, tmp_len);
concat_name[tmp_len] = '/';
strcpy (concat_name + tmp_len + 1, wrapper);
if (check_executable (concat_name))
return concat_name;
XFREE (concat_name);
return NULL;
}
char *
chase_symlinks (const char *pathspec)
{
#ifndef S_ISLNK
return xstrdup (pathspec);
#else
char buf[LT_PATHMAX];
struct stat s;
char *tmp_pathspec = xstrdup (pathspec);
char *p;
int has_symlinks = 0;
while (strlen (tmp_pathspec) && !has_symlinks)
{
lt_debugprintf (__FILE__, __LINE__,
"checking path component for symlinks: %s\n",
tmp_pathspec);
if (lstat (tmp_pathspec, &s) == 0)
{
if (S_ISLNK (s.st_mode) != 0)
{
has_symlinks = 1;
break;
}
/* search backwards for last DIR_SEPARATOR */
p = tmp_pathspec + strlen (tmp_pathspec) - 1;
while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
p--;
if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
{
/* no more DIR_SEPARATORS left */
break;
}
*p = '\0';
}
else
{
lt_fatal (__FILE__, __LINE__,
"error accessing file \"%s\": %s",
tmp_pathspec, nonnull (strerror (errno)));
}
}
XFREE (tmp_pathspec);
if (!has_symlinks)
{
return xstrdup (pathspec);
}
tmp_pathspec = realpath (pathspec, buf);
if (tmp_pathspec == 0)
{
lt_fatal (__FILE__, __LINE__,
"could not follow symlinks for %s", pathspec);
}
return xstrdup (tmp_pathspec);
#endif
}
char *
strendzap (char *str, const char *pat)
{
size_t len, patlen;
assert (str != NULL);
assert (pat != NULL);
len = strlen (str);
patlen = strlen (pat);
if (patlen <= len)
{
str += len - patlen;
if (strcmp (str, pat) == 0)
*str = '\0';
}
return str;
}
void
lt_debugprintf (const char *file, int line, const char *fmt, ...)
{
va_list args;
if (lt_debug)
{
(void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
va_start (args, fmt);
(void) vfprintf (stderr, fmt, args);
va_end (args);
}
}
static void
lt_error_core (int exit_status, const char *file,
int line, const char *mode,
const char *message, va_list ap)
{
fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
vfprintf (stderr, message, ap);
fprintf (stderr, ".\n");
if (exit_status >= 0)
exit (exit_status);
}
void
lt_fatal (const char *file, int line, const char *message, ...)
{
va_list ap;
va_start (ap, message);
lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
va_end (ap);
}
static const char *
nonnull (const char *s)
{
return s ? s : "(null)";
}
static const char *
nonempty (const char *s)
{
return (s && !*s) ? "(empty)" : nonnull (s);
}
void
lt_setenv (const char *name, const char *value)
{
lt_debugprintf (__FILE__, __LINE__,
"(lt_setenv) setting '%s' to '%s'\n",
nonnull (name), nonnull (value));
{
#ifdef HAVE_SETENV
/* always make a copy, for consistency with !HAVE_SETENV */
char *str = xstrdup (value);
setenv (name, str, 1);
#else
int len = strlen (name) + 1 + strlen (value) + 1;
char *str = XMALLOC (char, len);
sprintf (str, "%s=%s", name, value);
if (putenv (str) != EXIT_SUCCESS)
{
XFREE (str);
}
#endif
}
}
char *
lt_extend_str (const char *orig_value, const char *add, int to_end)
{
char *new_value;
if (orig_value && *orig_value)
{
int orig_value_len = strlen (orig_value);
int add_len = strlen (add);
new_value = XMALLOC (char, add_len + orig_value_len + 1);
if (to_end)
{
strcpy (new_value, orig_value);
strcpy (new_value + orig_value_len, add);
}
else
{
strcpy (new_value, add);
strcpy (new_value + add_len, orig_value);
}
}
else
{
new_value = xstrdup (add);
}
return new_value;
}
void
lt_update_exe_path (const char *name, const char *value)
{
lt_debugprintf (__FILE__, __LINE__,
"(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
nonnull (name), nonnull (value));
if (name && *name && value && *value)
{
char *new_value = lt_extend_str (getenv (name), value, 0);
/* some systems can't cope with a ':'-terminated path #' */
int len = strlen (new_value);
while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
{
new_value[len-1] = '\0';
}
lt_setenv (name, new_value);
XFREE (new_value);
}
}
void
lt_update_lib_path (const char *name, const char *value)
{
lt_debugprintf (__FILE__, __LINE__,
"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
nonnull (name), nonnull (value));
if (name && *name && value && *value)
{
char *new_value = lt_extend_str (getenv (name), value, 0);
lt_setenv (name, new_value);
XFREE (new_value);
}
}
EOF
case $host_os in
mingw*)
cat <<"EOF"
/* Prepares an argument vector before calling spawn().
Note that spawn() does not by itself call the command interpreter
(getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&v);
v.dwPlatformId == VER_PLATFORM_WIN32_NT;
}) ? "cmd.exe" : "command.com").
Instead it simply concatenates the arguments, separated by ' ', and calls
CreateProcess(). We must quote the arguments since Win32 CreateProcess()
interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
special way:
- Space and tab are interpreted as delimiters. They are not treated as
delimiters if they are surrounded by double quotes: "...".
- Unescaped double quotes are removed from the input. Their only effect is
that within double quotes, space and tab are treated like normal
characters.
- Backslashes not followed by double quotes are not special.
- But 2*n+1 backslashes followed by a double quote become
n backslashes followed by a double quote (n >= 0):
\" -> "
\\\" -> \"
\\\\\" -> \\"
*/
#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
char **
prepare_spawn (char **argv)
{
size_t argc;
char **new_argv;
size_t i;
/* Count number of arguments. */
for (argc = 0; argv[argc] != NULL; argc++)
;
/* Allocate new argument vector. */
new_argv = XMALLOC (char *, argc + 1);
/* Put quoted arguments into the new argument vector. */
for (i = 0; i < argc; i++)
{
const char *string = argv[i];
if (string[0] == '\0')
new_argv[i] = xstrdup ("\"\"");
else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
{
int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
size_t length;
unsigned int backslashes;
const char *s;
char *quoted_string;
char *p;
length = 0;
backslashes = 0;
if (quote_around)
length++;
for (s = string; *s != '\0'; s++)
{
char c = *s;
if (c == '"')
length += backslashes + 1;
length++;
if (c == '\\')
backslashes++;
else
backslashes = 0;
}
if (quote_around)
length += backslashes + 1;
quoted_string = XMALLOC (char, length + 1);
p = quoted_string;
backslashes = 0;
if (quote_around)
*p++ = '"';
for (s = string; *s != '\0'; s++)
{
char c = *s;
if (c == '"')
{
unsigned int j;
for (j = backslashes + 1; j > 0; j--)
*p++ = '\\';
}
*p++ = c;
if (c == '\\')
backslashes++;
else
backslashes = 0;
}
if (quote_around)
{
unsigned int j;
for (j = backslashes; j > 0; j--)
*p++ = '\\';
*p++ = '"';
}
*p = '\0';
new_argv[i] = quoted_string;
}
else
new_argv[i] = (char *) string;
}
new_argv[argc] = NULL;
return new_argv;
}
EOF
;;
esac
cat <<"EOF"
void lt_dump_script (FILE* f)
{
EOF
func_emit_wrapper yes |
$SED -n -e '
s/^\(.\{79\}\)\(..*\)/\1\
\2/
h
s/\([\\"]\)/\\\1/g
s/$/\\n/
s/\([^\n]*\).*/ fputs ("\1", f);/p
g
D'
cat <<"EOF"
}
EOF
}
# end: func_emit_cwrapperexe_src
# func_win32_import_lib_p ARG
# True if ARG is an import lib, as indicated by $file_magic_cmd
func_win32_import_lib_p ()
{
$opt_debug
case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
*import*) : ;;
*) false ;;
esac
}
# func_mode_link arg...
func_mode_link ()
{
$opt_debug
case $host in
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
# It is impossible to link a dll without this setting, and
# we shouldn't force the makefile maintainer to figure out
# which system we are compiling for in order to pass an extra
# flag for every libtool invocation.
# allow_undefined=no
# FIXME: Unfortunately, there are problems with the above when trying
# to make a dll which has undefined symbols, in which case not
# even a static library is built. For now, we need to specify
# -no-undefined on the libtool link line when we can be certain
# that all symbols are satisfied, otherwise we get a static library.
allow_undefined=yes
;;
*)
allow_undefined=yes
;;
esac
libtool_args=$nonopt
base_compile="$nonopt $@"
compile_command=$nonopt
finalize_command=$nonopt
compile_rpath=
finalize_rpath=
compile_shlibpath=
finalize_shlibpath=
convenience=
old_convenience=
deplibs=
old_deplibs=
compiler_flags=
linker_flags=
dllsearchpath=
lib_search_path=`pwd`
inst_prefix_dir=
new_inherited_linker_flags=
avoid_version=no
bindir=
dlfiles=
dlprefiles=
dlself=no
export_dynamic=no
export_symbols=
export_symbols_regex=
generated=
libobjs=
ltlibs=
module=no
no_install=no
objs=
non_pic_objects=
precious_files_regex=
prefer_static_libs=no
preload=no
prev=
prevarg=
release=
rpath=
xrpath=
perm_rpath=
temp_rpath=
thread_safe=no
vinfo=
vinfo_number=no
weak_libs=
single_module="${wl}-single_module"
func_infer_tag $base_compile
# We need to know -static, to get the right output filenames.
for arg
do
case $arg in
-shared)
test "$build_libtool_libs" != yes && \
func_fatal_configuration "can not build a shared library"
build_old_libs=no
break
;;
-all-static | -static | -static-libtool-libs)
case $arg in
-all-static)
if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
func_warning "complete static linking is impossible in this configuration"
fi
if test -n "$link_static_flag"; then
dlopen_self=$dlopen_self_static
fi
prefer_static_libs=yes
;;
-static)
if test -z "$pic_flag" && test -n "$link_static_flag"; then
dlopen_self=$dlopen_self_static
fi
prefer_static_libs=built
;;
-static-libtool-libs)
if test -z "$pic_flag" && test -n "$link_static_flag"; then
dlopen_self=$dlopen_self_static
fi
prefer_static_libs=yes
;;
esac
build_libtool_libs=no
build_old_libs=yes
break
;;
esac
done
# See if our shared archives depend on static archives.
test -n "$old_archive_from_new_cmds" && build_old_libs=yes
# Go through the arguments, transforming them on the way.
while test "$#" -gt 0; do
arg="$1"
shift
func_quote_for_eval "$arg"
qarg=$func_quote_for_eval_unquoted_result
func_append libtool_args " $func_quote_for_eval_result"
# If the previous option needs an argument, assign it.
if test -n "$prev"; then
case $prev in
output)
func_append compile_command " @OUTPUT@"
func_append finalize_command " @OUTPUT@"
;;
esac
case $prev in
bindir)
bindir="$arg"
prev=
continue
;;
dlfiles|dlprefiles)
if test "$preload" = no; then
# Add the symbol object into the linking commands.
func_append compile_command " @SYMFILE@"
func_append finalize_command " @SYMFILE@"
preload=yes
fi
case $arg in
*.la | *.lo) ;; # We handle these cases below.
force)
if test "$dlself" = no; then
dlself=needless
export_dynamic=yes
fi
prev=
continue
;;
self)
if test "$prev" = dlprefiles; then
dlself=yes
elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
dlself=yes
else
dlself=needless
export_dynamic=yes
fi
prev=
continue
;;
*)
if test "$prev" = dlfiles; then
func_append dlfiles " $arg"
else
func_append dlprefiles " $arg"
fi
prev=
continue
;;
esac
;;
expsyms)
export_symbols="$arg"
test -f "$arg" \
|| func_fatal_error "symbol file \`$arg' does not exist"
prev=
continue
;;
expsyms_regex)
export_symbols_regex="$arg"
prev=
continue
;;
framework)
case $host in
*-*-darwin*)
case "$deplibs " in
*" $qarg.ltframework "*) ;;
*) func_append deplibs " $qarg.ltframework" # this is fixed later
;;
esac
;;
esac
prev=
continue
;;
inst_prefix)
inst_prefix_dir="$arg"
prev=
continue
;;
objectlist)
if test -f "$arg"; then
save_arg=$arg
moreargs=
for fil in `cat "$save_arg"`
do
# func_append moreargs " $fil"
arg=$fil
# A libtool-controlled object.
# Check to see that this really is a libtool object.
if func_lalib_unsafe_p "$arg"; then
pic_object=
non_pic_object=
# Read the .lo file
func_source "$arg"
if test -z "$pic_object" ||
test -z "$non_pic_object" ||
test "$pic_object" = none &&
test "$non_pic_object" = none; then
func_fatal_error "cannot find name of object for \`$arg'"
fi
# Extract subdirectory from the argument.
func_dirname "$arg" "/" ""
xdir="$func_dirname_result"
if test "$pic_object" != none; then
# Prepend the subdirectory the object is found in.
pic_object="$xdir$pic_object"
if test "$prev" = dlfiles; then
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
func_append dlfiles " $pic_object"
prev=
continue
else
# If libtool objects are unsupported, then we need to preload.
prev=dlprefiles
fi
fi
# CHECK ME: I think I busted this. -Ossama
if test "$prev" = dlprefiles; then
# Preload the old-style object.
func_append dlprefiles " $pic_object"
prev=
fi
# A PIC object.
func_append libobjs " $pic_object"
arg="$pic_object"
fi
# Non-PIC object.
if test "$non_pic_object" != none; then
# Prepend the subdirectory the object is found in.
non_pic_object="$xdir$non_pic_object"
# A standard non-PIC object
func_append non_pic_objects " $non_pic_object"
if test -z "$pic_object" || test "$pic_object" = none ; then
arg="$non_pic_object"
fi
else
# If the PIC object exists, use it instead.
# $xdir was prepended to $pic_object above.
non_pic_object="$pic_object"
func_append non_pic_objects " $non_pic_object"
fi
else
# Only an error if not doing a dry-run.
if $opt_dry_run; then
# Extract subdirectory from the argument.
func_dirname "$arg" "/" ""
xdir="$func_dirname_result"
func_lo2o "$arg"
pic_object=$xdir$objdir/$func_lo2o_result
non_pic_object=$xdir$func_lo2o_result
func_append libobjs " $pic_object"
func_append non_pic_objects " $non_pic_object"
else
func_fatal_error "\`$arg' is not a valid libtool object"
fi
fi
done
else
func_fatal_error "link input file \`$arg' does not exist"
fi
arg=$save_arg
prev=
continue
;;
precious_regex)
precious_files_regex="$arg"
prev=
continue
;;
release)
release="-$arg"
prev=
continue
;;
rpath | xrpath)
# We need an absolute path.
case $arg in
[\\/]* | [A-Za-z]:[\\/]*) ;;
*)
func_fatal_error "only absolute run-paths are allowed"
;;
esac
if test "$prev" = rpath; then
case "$rpath " in
*" $arg "*) ;;
*) func_append rpath " $arg" ;;
esac
else
case "$xrpath " in
*" $arg "*) ;;
*) func_append xrpath " $arg" ;;
esac
fi
prev=
continue
;;
shrext)
shrext_cmds="$arg"
prev=
continue
;;
weak)
func_append weak_libs " $arg"
prev=
continue
;;
xcclinker)
func_append linker_flags " $qarg"
func_append compiler_flags " $qarg"
prev=
func_append compile_command " $qarg"
func_append finalize_command " $qarg"
continue
;;
xcompiler)
func_append compiler_flags " $qarg"
prev=
func_append compile_command " $qarg"
func_append finalize_command " $qarg"
continue
;;
xlinker)
func_append linker_flags " $qarg"
func_append compiler_flags " $wl$qarg"
prev=
func_append compile_command " $wl$qarg"
func_append finalize_command " $wl$qarg"
continue
;;
*)
eval "$prev=\"\$arg\""
prev=
continue
;;
esac
fi # test -n "$prev"
prevarg="$arg"
case $arg in
-all-static)
if test -n "$link_static_flag"; then
# See comment for -static flag below, for more details.
func_append compile_command " $link_static_flag"
func_append finalize_command " $link_static_flag"
fi
continue
;;
-allow-undefined)
# FIXME: remove this flag sometime in the future.
func_fatal_error "\`-allow-undefined' must not be used because it is the default"
;;
-avoid-version)
avoid_version=yes
continue
;;
-bindir)
prev=bindir
continue
;;
-dlopen)
prev=dlfiles
continue
;;
-dlpreopen)
prev=dlprefiles
continue
;;
-export-dynamic)
export_dynamic=yes
continue
;;
-export-symbols | -export-symbols-regex)
if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
func_fatal_error "more than one -exported-symbols argument is not allowed"
fi
if test "X$arg" = "X-export-symbols"; then
prev=expsyms
else
prev=expsyms_regex
fi
continue
;;
-framework)
prev=framework
continue
;;
-inst-prefix-dir)
prev=inst_prefix
continue
;;
# The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
# so, if we see these flags be careful not to treat them like -L
-L[A-Z][A-Z]*:*)
case $with_gcc/$host in
no/*-*-irix* | /*-*-irix*)
func_append compile_command " $arg"
func_append finalize_command " $arg"
;;
esac
continue
;;
-L*)
func_stripname "-L" '' "$arg"
if test -z "$func_stripname_result"; then
if test "$#" -gt 0; then
func_fatal_error "require no space between \`-L' and \`$1'"
else
func_fatal_error "need path for \`-L' option"
fi
fi
func_resolve_sysroot "$func_stripname_result"
dir=$func_resolve_sysroot_result
# We need an absolute path.
case $dir in
[\\/]* | [A-Za-z]:[\\/]*) ;;
*)
absdir=`cd "$dir" && pwd`
test -z "$absdir" && \
func_fatal_error "cannot determine absolute directory name of \`$dir'"
dir="$absdir"
;;
esac
case "$deplibs " in
*" -L$dir "* | *" $arg "*)
# Will only happen for absolute or sysroot arguments
;;
*)
# Preserve sysroot, but never include relative directories
case $dir in
[\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
*) func_append deplibs " -L$dir" ;;
esac
func_append lib_search_path " $dir"
;;
esac
case $host in
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
case :$dllsearchpath: in
*":$dir:"*) ;;
::) dllsearchpath=$dir;;
*) func_append dllsearchpath ":$dir";;
esac
case :$dllsearchpath: in
*":$testbindir:"*) ;;
::) dllsearchpath=$testbindir;;
*) func_append dllsearchpath ":$testbindir";;
esac
;;
esac
continue
;;
-l*)
if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
case $host in
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
# These systems don't actually have a C or math library (as such)
continue
;;
*-*-os2*)
# These systems don't actually have a C library (as such)
test "X$arg" = "X-lc" && continue
;;
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
# Do not include libc due to us having libc/libc_r.
test "X$arg" = "X-lc" && continue
;;
*-*-rhapsody* | *-*-darwin1.[012])
# Rhapsody C and math libraries are in the System framework
func_append deplibs " System.ltframework"
continue
;;
*-*-sco3.2v5* | *-*-sco5v6*)
# Causes problems with __ctype
test "X$arg" = "X-lc" && continue
;;
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
# Compiler inserts libc in the correct place for threads to work
test "X$arg" = "X-lc" && continue
;;
esac
elif test "X$arg" = "X-lc_r"; then
case $host in
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
# Do not include libc_r directly, use -pthread flag.
continue
;;
esac
fi
func_append deplibs " $arg"
continue
;;
-module)
module=yes
continue
;;
# Tru64 UNIX uses -model [arg] to determine the layout of C++
# classes, name mangling, and exception handling.
# Darwin uses the -arch flag to determine output architecture.
-model|-arch|-isysroot|--sysroot)
func_append compiler_flags " $arg"
func_append compile_command " $arg"
func_append finalize_command " $arg"
prev=xcompiler
continue
;;
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
|-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
func_append compiler_flags " $arg"
func_append compile_command " $arg"
func_append finalize_command " $arg"
case "$new_inherited_linker_flags " in
*" $arg "*) ;;
* ) func_append new_inherited_linker_flags " $arg" ;;
esac
continue
;;
-multi_module)
single_module="${wl}-multi_module"
continue
;;
-no-fast-install)
fast_install=no
continue
;;
-no-install)
case $host in
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
# The PATH hackery in wrapper scripts is required on Windows
# and Darwin in order for the loader to find any dlls it needs.
func_warning "\`-no-install' is ignored for $host"
func_warning "assuming \`-no-fast-install' instead"
fast_install=no
;;
*) no_install=yes ;;
esac
continue
;;
-no-undefined)
allow_undefined=no
continue
;;
-objectlist)
prev=objectlist
continue
;;
-o) prev=output ;;
-precious-files-regex)
prev=precious_regex
continue
;;
-release)
prev=release
continue
;;
-rpath)
prev=rpath
continue
;;
-R)
prev=xrpath
continue
;;
-R*)
func_stripname '-R' '' "$arg"
dir=$func_stripname_result
# We need an absolute path.
case $dir in
[\\/]* | [A-Za-z]:[\\/]*) ;;
=*)
func_stripname '=' '' "$dir"
dir=$lt_sysroot$func_stripname_result
;;
*)
func_fatal_error "only absolute run-paths are allowed"
;;
esac
case "$xrpath " in
*" $dir "*) ;;
*) func_append xrpath " $dir" ;;
esac
continue
;;
-shared)
# The effects of -shared are defined in a previous loop.
continue
;;
-shrext)
prev=shrext
continue
;;
-static | -static-libtool-libs)
# The effects of -static are defined in a previous loop.
# We used to do the same as -all-static on platforms that
# didn't have a PIC flag, but the assumption that the effects
# would be equivalent was wrong. It would break on at least
# Digital Unix and AIX.
continue
;;
-thread-safe)
thread_safe=yes
continue
;;
-version-info)
prev=vinfo
continue
;;
-version-number)
prev=vinfo
vinfo_number=yes
continue
;;
-weak)
prev=weak
continue
;;
-Wc,*)
func_stripname '-Wc,' '' "$arg"
args=$func_stripname_result
arg=
save_ifs="$IFS"; IFS=','
for flag in $args; do
IFS="$save_ifs"
func_quote_for_eval "$flag"
func_append arg " $func_quote_for_eval_result"
func_append compiler_flags " $func_quote_for_eval_result"
done
IFS="$save_ifs"
func_stripname ' ' '' "$arg"
arg=$func_stripname_result
;;
-Wl,*)
func_stripname '-Wl,' '' "$arg"
args=$func_stripname_result
arg=
save_ifs="$IFS"; IFS=','
for flag in $args; do
IFS="$save_ifs"
func_quote_for_eval "$flag"
func_append arg " $wl$func_quote_for_eval_result"
func_append compiler_flags " $wl$func_quote_for_eval_result"
func_append linker_flags " $func_quote_for_eval_result"
done
IFS="$save_ifs"
func_stripname ' ' '' "$arg"
arg=$func_stripname_result
;;
-Xcompiler)
prev=xcompiler
continue
;;
-Xlinker)
prev=xlinker
continue
;;
-XCClinker)
prev=xcclinker
continue
;;
# -msg_* for osf cc
-msg_*)
func_quote_for_eval "$arg"
arg="$func_quote_for_eval_result"
;;
# Flags to be passed through unchanged, with rationale:
# -64, -mips[0-9] enable 64-bit mode for the SGI compiler
# -r[0-9][0-9]* specify processor for the SGI compiler
# -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
# +DA*, +DD* enable 64-bit mode for the HP compiler
# -q* compiler args for the IBM compiler
# -m*, -t[45]*, -txscale* architecture-specific flags for GCC
# -F/path path to uninstalled frameworks, gcc on darwin
# -p, -pg, --coverage, -fprofile-* profiling flags for GCC
# @file GCC response files
# -tp=* Portland pgcc target processor selection
# --sysroot=* for sysroot support
# -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
-O*|-flto*|-fwhopr*|-fuse-linker-plugin)
func_quote_for_eval "$arg"
arg="$func_quote_for_eval_result"
func_append compile_command " $arg"
func_append finalize_command " $arg"
func_append compiler_flags " $arg"
continue
;;
# Some other compiler flag.
-* | +*)
func_quote_for_eval "$arg"
arg="$func_quote_for_eval_result"
;;
*.$objext)
# A standard object.
func_append objs " $arg"
;;
*.lo)
# A libtool-controlled object.
# Check to see that this really is a libtool object.
if func_lalib_unsafe_p "$arg"; then
pic_object=
non_pic_object=
# Read the .lo file
func_source "$arg"
if test -z "$pic_object" ||
test -z "$non_pic_object" ||
test "$pic_object" = none &&
test "$non_pic_object" = none; then
func_fatal_error "cannot find name of object for \`$arg'"
fi
# Extract subdirectory from the argument.
func_dirname "$arg" "/" ""
xdir="$func_dirname_result"
if test "$pic_object" != none; then
# Prepend the subdirectory the object is found in.
pic_object="$xdir$pic_object"
if test "$prev" = dlfiles; then
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
func_append dlfiles " $pic_object"
prev=
continue
else
# If libtool objects are unsupported, then we need to preload.
prev=dlprefiles
fi
fi
# CHECK ME: I think I busted this. -Ossama
if test "$prev" = dlprefiles; then
# Preload the old-style object.
func_append dlprefiles " $pic_object"
prev=
fi
# A PIC object.
func_append libobjs " $pic_object"
arg="$pic_object"
fi
# Non-PIC object.
if test "$non_pic_object" != none; then
# Prepend the subdirectory the object is found in.
non_pic_object="$xdir$non_pic_object"
# A standard non-PIC object
func_append non_pic_objects " $non_pic_object"
if test -z "$pic_object" || test "$pic_object" = none ; then
arg="$non_pic_object"
fi
else
# If the PIC object exists, use it instead.
# $xdir was prepended to $pic_object above.
non_pic_object="$pic_object"
func_append non_pic_objects " $non_pic_object"
fi
else
# Only an error if not doing a dry-run.
if $opt_dry_run; then
# Extract subdirectory from the argument.
func_dirname "$arg" "/" ""
xdir="$func_dirname_result"
func_lo2o "$arg"
pic_object=$xdir$objdir/$func_lo2o_result
non_pic_object=$xdir$func_lo2o_result
func_append libobjs " $pic_object"
func_append non_pic_objects " $non_pic_object"
else
func_fatal_error "\`$arg' is not a valid libtool object"
fi
fi
;;
*.$libext)
# An archive.
func_append deplibs " $arg"
func_append old_deplibs " $arg"
continue
;;
*.la)
# A libtool-controlled library.
func_resolve_sysroot "$arg"
if test "$prev" = dlfiles; then
# This library was specified with -dlopen.
func_append dlfiles " $func_resolve_sysroot_result"
prev=
elif test "$prev" = dlprefiles; then
# The library was specified with -dlpreopen.
func_append dlprefiles " $func_resolve_sysroot_result"
prev=
else
func_append deplibs " $func_resolve_sysroot_result"
fi
continue
;;
# Some other compiler argument.
*)
# Unknown arguments in both finalize_command and compile_command need
# to be aesthetically quoted because they are evaled later.
func_quote_for_eval "$arg"
arg="$func_quote_for_eval_result"
;;
esac # arg
# Now actually substitute the argument into the commands.
if test -n "$arg"; then
func_append compile_command " $arg"
func_append finalize_command " $arg"
fi
done # argument parsing loop
test -n "$prev" && \
func_fatal_help "the \`$prevarg' option requires an argument"
if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
eval arg=\"$export_dynamic_flag_spec\"
func_append compile_command " $arg"
func_append finalize_command " $arg"
fi
oldlibs=
# calculate the name of the file, without its directory
func_basename "$output"
outputname="$func_basename_result"
libobjs_save="$libobjs"
if test -n "$shlibpath_var"; then
# get the directories listed in $shlibpath_var
eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
else
shlib_search_path=
fi
eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
func_dirname "$output" "/" ""
output_objdir="$func_dirname_result$objdir"
func_to_tool_file "$output_objdir/"
tool_output_objdir=$func_to_tool_file_result
# Create the object directory.
func_mkdir_p "$output_objdir"
# Determine the type of output
case $output in
"")
func_fatal_help "you must specify an output file"
;;
*.$libext) linkmode=oldlib ;;
*.lo | *.$objext) linkmode=obj ;;
*.la) linkmode=lib ;;
*) linkmode=prog ;; # Anything else should be a program.
esac
specialdeplibs=
libs=
# Find all interdependent deplibs by searching for libraries
# that are linked more than once (e.g. -la -lb -la)
for deplib in $deplibs; do
if $opt_preserve_dup_deps ; then
case "$libs " in
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
esac
fi
func_append libs " $deplib"
done
if test "$linkmode" = lib; then
libs="$predeps $libs $compiler_lib_search_path $postdeps"
# Compute libraries that are listed more than once in $predeps
# $postdeps and mark them as special (i.e., whose duplicates are
# not to be eliminated).
pre_post_deps=
if $opt_duplicate_compiler_generated_deps; then
for pre_post_dep in $predeps $postdeps; do
case "$pre_post_deps " in
*" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
esac
func_append pre_post_deps " $pre_post_dep"
done
fi
pre_post_deps=
fi
deplibs=
newdependency_libs=
newlib_search_path=
need_relink=no # whether we're linking any uninstalled libtool libraries
notinst_deplibs= # not-installed libtool libraries
notinst_path= # paths that contain not-installed libtool libraries
case $linkmode in
lib)
passes="conv dlpreopen link"
for file in $dlfiles $dlprefiles; do
case $file in
*.la) ;;
*)
func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
;;
esac
done
;;
prog)
compile_deplibs=
finalize_deplibs=
alldeplibs=no
newdlfiles=
newdlprefiles=
passes="conv scan dlopen dlpreopen link"
;;
*) passes="conv"
;;
esac
for pass in $passes; do
# The preopen pass in lib mode reverses $deplibs; put it back here
# so that -L comes before libs that need it for instance...
if test "$linkmode,$pass" = "lib,link"; then
## FIXME: Find the place where the list is rebuilt in the wrong
## order, and fix it there properly
tmp_deplibs=
for deplib in $deplibs; do
tmp_deplibs="$deplib $tmp_deplibs"
done
deplibs="$tmp_deplibs"
fi
if test "$linkmode,$pass" = "lib,link" ||
test "$linkmode,$pass" = "prog,scan"; then
libs="$deplibs"
deplibs=
fi
if test "$linkmode" = prog; then
case $pass in
dlopen) libs="$dlfiles" ;;
dlpreopen) libs="$dlprefiles" ;;
link)
libs="$deplibs %DEPLIBS%"
test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
;;
esac
fi
if test "$linkmode,$pass" = "lib,dlpreopen"; then
# Collect and forward deplibs of preopened libtool libs
for lib in $dlprefiles; do
# Ignore non-libtool-libs
dependency_libs=
func_resolve_sysroot "$lib"
case $lib in
*.la) func_source "$func_resolve_sysroot_result" ;;
esac
# Collect preopened libtool deplibs, except any this library
# has declared as weak libs
for deplib in $dependency_libs; do
func_basename "$deplib"
deplib_base=$func_basename_result
case " $weak_libs " in
*" $deplib_base "*) ;;
*) func_append deplibs " $deplib" ;;
esac
done
done
libs="$dlprefiles"
fi
if test "$pass" = dlopen; then
# Collect dlpreopened libraries
save_deplibs="$deplibs"
deplibs=
fi
for deplib in $libs; do
lib=
found=no
case $deplib in
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
|-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
if test "$linkmode,$pass" = "prog,link"; then
compile_deplibs="$deplib $compile_deplibs"
finalize_deplibs="$deplib $finalize_deplibs"
else
func_append compiler_flags " $deplib"
if test "$linkmode" = lib ; then
case "$new_inherited_linker_flags " in
*" $deplib "*) ;;
* ) func_append new_inherited_linker_flags " $deplib" ;;
esac
fi
fi
continue
;;
-l*)
if test "$linkmode" != lib && test "$linkmode" != prog; then
func_warning "\`-l' is ignored for archives/objects"
continue
fi
func_stripname '-l' '' "$deplib"
name=$func_stripname_result
if test "$linkmode" = lib; then
searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
else
searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
fi
for searchdir in $searchdirs; do
for search_ext in .la $std_shrext .so .a; do
# Search the libtool library
lib="$searchdir/lib${name}${search_ext}"
if test -f "$lib"; then
if test "$search_ext" = ".la"; then
found=yes
else
found=no
fi
break 2
fi
done
done
if test "$found" != yes; then
# deplib doesn't seem to be a libtool library
if test "$linkmode,$pass" = "prog,link"; then
compile_deplibs="$deplib $compile_deplibs"
finalize_deplibs="$deplib $finalize_deplibs"
else
deplibs="$deplib $deplibs"
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
fi
continue
else # deplib is a libtool library
# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
# We need to do some special things here, and not later.
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
case " $predeps $postdeps " in
*" $deplib "*)
if func_lalib_p "$lib"; then
library_names=
old_library=
func_source "$lib"
for l in $old_library $library_names; do
ll="$l"
done
if test "X$ll" = "X$old_library" ; then # only static version available
found=no
func_dirname "$lib" "" "."
ladir="$func_dirname_result"
lib=$ladir/$old_library
if test "$linkmode,$pass" = "prog,link"; then
compile_deplibs="$deplib $compile_deplibs"
finalize_deplibs="$deplib $finalize_deplibs"
else
deplibs="$deplib $deplibs"
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
fi
continue
fi
fi
;;
*) ;;
esac
fi
fi
;; # -l
*.ltframework)
if test "$linkmode,$pass" = "prog,link"; then
compile_deplibs="$deplib $compile_deplibs"
finalize_deplibs="$deplib $finalize_deplibs"
else
deplibs="$deplib $deplibs"
if test "$linkmode" = lib ; then
case "$new_inherited_linker_flags " in
*" $deplib "*) ;;
* ) func_append new_inherited_linker_flags " $deplib" ;;
esac
fi
fi
continue
;;
-L*)
case $linkmode in
lib)
deplibs="$deplib $deplibs"
test "$pass" = conv && continue
newdependency_libs="$deplib $newdependency_libs"
func_stripname '-L' '' "$deplib"
func_resolve_sysroot "$func_stripname_result"
func_append newlib_search_path " $func_resolve_sysroot_result"
;;
prog)
if test "$pass" = conv; then
deplibs="$deplib $deplibs"
continue
fi
if test "$pass" = scan; then
deplibs="$deplib $deplibs"
else
compile_deplibs="$deplib $compile_deplibs"
finalize_deplibs="$deplib $finalize_deplibs"
fi
func_stripname '-L' '' "$deplib"
func_resolve_sysroot "$func_stripname_result"
func_append newlib_search_path " $func_resolve_sysroot_result"
;;
*)
func_warning "\`-L' is ignored for archives/objects"
;;
esac # linkmode
continue
;; # -L
-R*)
if test "$pass" = link; then
func_stripname '-R' '' "$deplib"
func_resolve_sysroot "$func_stripname_result"
dir=$func_resolve_sysroot_result
# Make sure the xrpath contains only unique directories.
case "$xrpath " in
*" $dir "*) ;;
*) func_append xrpath " $dir" ;;
esac
fi
deplibs="$deplib $deplibs"
continue
;;
*.la)
func_resolve_sysroot "$deplib"
lib=$func_resolve_sysroot_result
;;
*.$libext)
if test "$pass" = conv; then
deplibs="$deplib $deplibs"
continue
fi
case $linkmode in
lib)
# Linking convenience modules into shared libraries is allowed,
# but linking other static libraries is non-portable.
case " $dlpreconveniencelibs " in
*" $deplib "*) ;;
*)
valid_a_lib=no
case $deplibs_check_method in
match_pattern*)
set dummy $deplibs_check_method; shift
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
| $EGREP "$match_pattern_regex" > /dev/null; then
valid_a_lib=yes
fi
;;
pass_all)
valid_a_lib=yes
;;
esac
if test "$valid_a_lib" != yes; then
echo
$ECHO "*** Warning: Trying to link with static lib archive $deplib."
echo "*** I have the capability to make that library automatically link in when"
echo "*** you link to this library. But I can only do this if you have a"
echo "*** shared version of the library, which you do not appear to have"
echo "*** because the file extensions .$libext of this argument makes me believe"
echo "*** that it is just a static archive that I should not use here."
else
echo
$ECHO "*** Warning: Linking the shared library $output against the"
$ECHO "*** static library $deplib is not portable!"
deplibs="$deplib $deplibs"
fi
;;
esac
continue
;;
prog)
if test "$pass" != link; then
deplibs="$deplib $deplibs"
else
compile_deplibs="$deplib $compile_deplibs"
finalize_deplibs="$deplib $finalize_deplibs"
fi
continue
;;
esac # linkmode
;; # *.$libext
*.lo | *.$objext)
if test "$pass" = conv; then
deplibs="$deplib $deplibs"
elif test "$linkmode" = prog; then
if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
# If there is no dlopen support or we're linking statically,
# we need to preload.
func_append newdlprefiles " $deplib"
compile_deplibs="$deplib $compile_deplibs"
finalize_deplibs="$deplib $finalize_deplibs"
else
func_append newdlfiles " $deplib"
fi
fi
continue
;;
%DEPLIBS%)
alldeplibs=yes
continue
;;
esac # case $deplib
if test "$found" = yes || test -f "$lib"; then :
else
func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
fi
# Check to see that this really is a libtool archive.
func_lalib_unsafe_p "$lib" \
|| func_fatal_error "\`$lib' is not a valid libtool archive"
func_dirname "$lib" "" "."
ladir="$func_dirname_result"
dlname=
dlopen=
dlpreopen=
libdir=
library_names=
old_library=
inherited_linker_flags=
# If the library was installed with an old release of libtool,
# it will not redefine variables installed, or shouldnotlink
installed=yes
shouldnotlink=no
avoidtemprpath=
# Read the .la file
func_source "$lib"
# Convert "-framework foo" to "foo.ltframework"
if test -n "$inherited_linker_flags"; then
tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
case " $new_inherited_linker_flags " in
*" $tmp_inherited_linker_flag "*) ;;
*) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
esac
done
fi
dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
if test "$linkmode,$pass" = "lib,link" ||
test "$linkmode,$pass" = "prog,scan" ||
{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
test -n "$dlopen" && func_append dlfiles " $dlopen"
test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
fi
if test "$pass" = conv; then
# Only check for convenience libraries
deplibs="$lib $deplibs"
if test -z "$libdir"; then
if test -z "$old_library"; then
func_fatal_error "cannot find name of link library for \`$lib'"
fi
# It is a libtool convenience library, so add in its objects.
func_append convenience " $ladir/$objdir/$old_library"
func_append old_convenience " $ladir/$objdir/$old_library"
tmp_libs=
for deplib in $dependency_libs; do
deplibs="$deplib $deplibs"
if $opt_preserve_dup_deps ; then
case "$tmp_libs " in
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
esac
fi
func_append tmp_libs " $deplib"
done
elif test "$linkmode" != prog && test "$linkmode" != lib; then
func_fatal_error "\`$lib' is not a convenience library"
fi
continue
fi # $pass = conv
# Get the name of the library we link against.
linklib=
if test -n "$old_library" &&
{ test "$prefer_static_libs" = yes ||
test "$prefer_static_libs,$installed" = "built,no"; }; then
linklib=$old_library
else
for l in $old_library $library_names; do
linklib="$l"
done
fi
if test -z "$linklib"; then
func_fatal_error "cannot find name of link library for \`$lib'"
fi
# This library was specified with -dlopen.
if test "$pass" = dlopen; then
if test -z "$libdir"; then
func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
fi
if test -z "$dlname" ||
test "$dlopen_support" != yes ||
test "$build_libtool_libs" = no; then
# If there is no dlname, no dlopen support or we're linking
# statically, we need to preload. We also need to preload any
# dependent libraries so libltdl's deplib preloader doesn't
# bomb out in the load deplibs phase.
func_append dlprefiles " $lib $dependency_libs"
else
func_append newdlfiles " $lib"
fi
continue
fi # $pass = dlopen
# We need an absolute path.
case $ladir in
[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
*)
abs_ladir=`cd "$ladir" && pwd`
if test -z "$abs_ladir"; then
func_warning "cannot determine absolute directory name of \`$ladir'"
func_warning "passing it literally to the linker, although it might fail"
abs_ladir="$ladir"
fi
;;
esac
func_basename "$lib"
laname="$func_basename_result"
# Find the relevant object directory and library name.
if test "X$installed" = Xyes; then
if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
func_warning "library \`$lib' was moved."
dir="$ladir"
absdir="$abs_ladir"
libdir="$abs_ladir"
else
dir="$lt_sysroot$libdir"
absdir="$lt_sysroot$libdir"
fi
test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
else
if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
dir="$ladir"
absdir="$abs_ladir"
# Remove this search path later
func_append notinst_path " $abs_ladir"
else
dir="$ladir/$objdir"
absdir="$abs_ladir/$objdir"
# Remove this search path later
func_append notinst_path " $abs_ladir"
fi
fi # $installed = yes
func_stripname 'lib' '.la' "$laname"
name=$func_stripname_result
# This library was specified with -dlpreopen.
if test "$pass" = dlpreopen; then
if test -z "$libdir" && test "$linkmode" = prog; then
func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
fi
case "$host" in
# special handling for platforms with PE-DLLs.
*cygwin* | *mingw* | *cegcc* )
# Linker will automatically link against shared library if both
# static and shared are present. Therefore, ensure we extract
# symbols from the import library if a shared library is present
# (otherwise, the dlopen module name will be incorrect). We do
# this by putting the import library name into $newdlprefiles.
# We recover the dlopen module name by 'saving' the la file
# name in a special purpose variable, and (later) extracting the
# dlname from the la file.
if test -n "$dlname"; then
func_tr_sh "$dir/$linklib"
eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
func_append newdlprefiles " $dir/$linklib"
else
func_append newdlprefiles " $dir/$old_library"
# Keep a list of preopened convenience libraries to check
# that they are being used correctly in the link pass.
test -z "$libdir" && \
func_append dlpreconveniencelibs " $dir/$old_library"
fi
;;
* )
# Prefer using a static library (so that no silly _DYNAMIC symbols
# are required to link).
if test -n "$old_library"; then
func_append newdlprefiles " $dir/$old_library"
# Keep a list of preopened convenience libraries to check
# that they are being used correctly in the link pass.
test -z "$libdir" && \
func_append dlpreconveniencelibs " $dir/$old_library"
# Otherwise, use the dlname, so that lt_dlopen finds it.
elif test -n "$dlname"; then
func_append newdlprefiles " $dir/$dlname"
else
func_append newdlprefiles " $dir/$linklib"
fi
;;
esac
fi # $pass = dlpreopen
if test -z "$libdir"; then
# Link the convenience library
if test "$linkmode" = lib; then
deplibs="$dir/$old_library $deplibs"
elif test "$linkmode,$pass" = "prog,link"; then
compile_deplibs="$dir/$old_library $compile_deplibs"
finalize_deplibs="$dir/$old_library $finalize_deplibs"
else
deplibs="$lib $deplibs" # used for prog,scan pass
fi
continue
fi
if test "$linkmode" = prog && test "$pass" != link; then
func_append newlib_search_path " $ladir"
deplibs="$lib $deplibs"
linkalldeplibs=no
if test "$link_all_deplibs" != no || test -z "$library_names" ||
test "$build_libtool_libs" = no; then
linkalldeplibs=yes
fi
tmp_libs=
for deplib in $dependency_libs; do
case $deplib in
-L*) func_stripname '-L' '' "$deplib"
func_resolve_sysroot "$func_stripname_result"
func_append newlib_search_path " $func_resolve_sysroot_result"
;;
esac
# Need to link against all dependency_libs?
if test "$linkalldeplibs" = yes; then
deplibs="$deplib $deplibs"
else
# Need to hardcode shared library paths
# or/and link against static libraries
newdependency_libs="$deplib $newdependency_libs"
fi
if $opt_preserve_dup_deps ; then
case "$tmp_libs " in
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
esac
fi
func_append tmp_libs " $deplib"
done # for deplib
continue
fi # $linkmode = prog...
if test "$linkmode,$pass" = "prog,link"; then
if test -n "$library_names" &&
{ { test "$prefer_static_libs" = no ||
test "$prefer_static_libs,$installed" = "built,yes"; } ||
test -z "$old_library"; }; then
# We need to hardcode the library path
if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
# Make sure the rpath contains only unique directories.
case "$temp_rpath:" in
*"$absdir:"*) ;;
*) func_append temp_rpath "$absdir:" ;;
esac
fi
# Hardcode the library path.
# Skip directories that are in the system default run-time
# search path.
case " $sys_lib_dlsearch_path " in
*" $absdir "*) ;;
*)
case "$compile_rpath " in
*" $absdir "*) ;;
*) func_append compile_rpath " $absdir" ;;
esac
;;
esac
case " $sys_lib_dlsearch_path " in
*" $libdir "*) ;;
*)
case "$finalize_rpath " in
*" $libdir "*) ;;
*) func_append finalize_rpath " $libdir" ;;
esac
;;
esac
fi # $linkmode,$pass = prog,link...
if test "$alldeplibs" = yes &&
{ test "$deplibs_check_method" = pass_all ||
{ test "$build_libtool_libs" = yes &&
test -n "$library_names"; }; }; then
# We only need to search for static libraries
continue
fi
fi
link_static=no # Whether the deplib will be linked statically
use_static_libs=$prefer_static_libs
if test "$use_static_libs" = built && test "$installed" = yes; then
use_static_libs=no
fi
if test -n "$library_names" &&
{ test "$use_static_libs" = no || test -z "$old_library"; }; then
case $host in
*cygwin* | *mingw* | *cegcc*)
# No point in relinking DLLs because paths are not encoded
func_append notinst_deplibs " $lib"
need_relink=no
;;
*)
if test "$installed" = no; then
func_append notinst_deplibs " $lib"
need_relink=yes
fi
;;
esac
# This is a shared library
# Warn about portability, can't link against -module's on some
# systems (darwin). Don't bleat about dlopened modules though!
dlopenmodule=""
for dlpremoduletest in $dlprefiles; do
if test "X$dlpremoduletest" = "X$lib"; then
dlopenmodule="$dlpremoduletest"
break
fi
done
if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
echo
if test "$linkmode" = prog; then
$ECHO "*** Warning: Linking the executable $output against the loadable module"
else
$ECHO "*** Warning: Linking the shared library $output against the loadable module"
fi
$ECHO "*** $linklib is not portable!"
fi
if test "$linkmode" = lib &&
test "$hardcode_into_libs" = yes; then
# Hardcode the library path.
# Skip directories that are in the system default run-time
# search path.
case " $sys_lib_dlsearch_path " in
*" $absdir "*) ;;
*)
case "$compile_rpath " in
*" $absdir "*) ;;
*) func_append compile_rpath " $absdir" ;;
esac
;;
esac
case " $sys_lib_dlsearch_path " in
*" $libdir "*) ;;
*)
case "$finalize_rpath " in
*" $libdir "*) ;;
*) func_append finalize_rpath " $libdir" ;;
esac
;;
esac
fi
if test -n "$old_archive_from_expsyms_cmds"; then
# figure out the soname
set dummy $library_names
shift
realname="$1"
shift
libname=`eval "\\$ECHO \"$libname_spec\""`
# use dlname if we got it. it's perfectly good, no?
if test -n "$dlname"; then
soname="$dlname"
elif test -n "$soname_spec"; then
# bleh windows
case $host in
*cygwin* | mingw* | *cegcc*)
func_arith $current - $age
major=$func_arith_result
versuffix="-$major"
;;
esac
eval soname=\"$soname_spec\"
else
soname="$realname"
fi
# Make a new name for the extract_expsyms_cmds to use
soroot="$soname"
func_basename "$soroot"
soname="$func_basename_result"
func_stripname 'lib' '.dll' "$soname"
newlib=libimp-$func_stripname_result.a
# If the library has no export list, then create one now
if test -f "$output_objdir/$soname-def"; then :
else
func_verbose "extracting exported symbol list from \`$soname'"
func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
fi
# Create $newlib
if test -f "$output_objdir/$newlib"; then :; else
func_verbose "generating import library for \`$soname'"
func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
fi
# make sure the library variables are pointing to the new library
dir=$output_objdir
linklib=$newlib
fi # test -n "$old_archive_from_expsyms_cmds"
if test "$linkmode" = prog || test "$opt_mode" != relink; then
add_shlibpath=
add_dir=
add=
lib_linked=yes
case $hardcode_action in
immediate | unsupported)
if test "$hardcode_direct" = no; then
add="$dir/$linklib"
case $host in
*-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
*-*-sysv4*uw2*) add_dir="-L$dir" ;;
*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
*-*-unixware7*) add_dir="-L$dir" ;;
*-*-darwin* )
# if the lib is a (non-dlopened) module then we can not
# link against it, someone is ignoring the earlier warnings
if /usr/bin/file -L $add 2> /dev/null |
$GREP ": [^:]* bundle" >/dev/null ; then
if test "X$dlopenmodule" != "X$lib"; then
$ECHO "*** Warning: lib $linklib is a module, not a shared library"
if test -z "$old_library" ; then
echo
echo "*** And there doesn't seem to be a static archive available"
echo "*** The link will probably fail, sorry"
else
add="$dir/$old_library"
fi
elif test -n "$old_library"; then
add="$dir/$old_library"
fi
fi
esac
elif test "$hardcode_minus_L" = no; then
case $host in
*-*-sunos*) add_shlibpath="$dir" ;;
esac
add_dir="-L$dir"
add="-l$name"
elif test "$hardcode_shlibpath_var" = no; then
add_shlibpath="$dir"
add="-l$name"
else
lib_linked=no
fi
;;
relink)
if test "$hardcode_direct" = yes &&
test "$hardcode_direct_absolute" = no; then
add="$dir/$linklib"
elif test "$hardcode_minus_L" = yes; then
add_dir="-L$absdir"
# Try looking first in the location we're being installed to.
if test -n "$inst_prefix_dir"; then
case $libdir in
[\\/]*)
func_append add_dir " -L$inst_prefix_dir$libdir"
;;
esac
fi
add="-l$name"
elif test "$hardcode_shlibpath_var" = yes; then
add_shlibpath="$dir"
add="-l$name"
else
lib_linked=no
fi
;;
*) lib_linked=no ;;
esac
if test "$lib_linked" != yes; then
func_fatal_configuration "unsupported hardcode properties"
fi
if test -n "$add_shlibpath"; then
case :$compile_shlibpath: in
*":$add_shlibpath:"*) ;;
*) func_append compile_shlibpath "$add_shlibpath:" ;;
esac
fi
if test "$linkmode" = prog; then
test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
test -n "$add" && compile_deplibs="$add $compile_deplibs"
else
test -n "$add_dir" && deplibs="$add_dir $deplibs"
test -n "$add" && deplibs="$add $deplibs"
if test "$hardcode_direct" != yes &&
test "$hardcode_minus_L" != yes &&
test "$hardcode_shlibpath_var" = yes; then
case :$finalize_shlibpath: in
*":$libdir:"*) ;;
*) func_append finalize_shlibpath "$libdir:" ;;
esac
fi
fi
fi
if test "$linkmode" = prog || test "$opt_mode" = relink; then
add_shlibpath=
add_dir=
add=
# Finalize command for both is simple: just hardcode it.
if test "$hardcode_direct" = yes &&
test "$hardcode_direct_absolute" = no; then
add="$libdir/$linklib"
elif test "$hardcode_minus_L" = yes; then
add_dir="-L$libdir"
add="-l$name"
elif test "$hardcode_shlibpath_var" = yes; then
case :$finalize_shlibpath: in
*":$libdir:"*) ;;
*) func_append finalize_shlibpath "$libdir:" ;;
esac
add="-l$name"
elif test "$hardcode_automatic" = yes; then
if test -n "$inst_prefix_dir" &&
test -f "$inst_prefix_dir$libdir/$linklib" ; then
add="$inst_prefix_dir$libdir/$linklib"
else
add="$libdir/$linklib"
fi
else
# We cannot seem to hardcode it, guess we'll fake it.
add_dir="-L$libdir"
# Try looking first in the location we're being installed to.
if test -n "$inst_prefix_dir"; then
case $libdir in
[\\/]*)
func_append add_dir " -L$inst_prefix_dir$libdir"
;;
esac
fi
add="-l$name"
fi
if test "$linkmode" = prog; then
test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
else
test -n "$add_dir" && deplibs="$add_dir $deplibs"
test -n "$add" && deplibs="$add $deplibs"
fi
fi
elif test "$linkmode" = prog; then
# Here we assume that one of hardcode_direct or hardcode_minus_L
# is not unsupported. This is valid on all known static and
# shared platforms.
if test "$hardcode_direct" != unsupported; then
test -n "$old_library" && linklib="$old_library"
compile_deplibs="$dir/$linklib $compile_deplibs"
finalize_deplibs="$dir/$linklib $finalize_deplibs"
else
compile_deplibs="-l$name -L$dir $compile_deplibs"
finalize_deplibs="-l$name -L$dir $finalize_deplibs"
fi
elif test "$build_libtool_libs" = yes; then
# Not a shared library
if test "$deplibs_check_method" != pass_all; then
# We're trying link a shared library against a static one
# but the system doesn't support it.
# Just print a warning and add the library to dependency_libs so
# that the program can be linked against the static library.
echo
$ECHO "*** Warning: This system can not link to static lib archive $lib."
echo "*** I have the capability to make that library automatically link in when"
echo "*** you link to this library. But I can only do this if you have a"
echo "*** shared version of the library, which you do not appear to have."
if test "$module" = yes; then
echo "*** But as you try to build a module library, libtool will still create "
echo "*** a static module, that should work as long as the dlopening application"
echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
if test -z "$global_symbol_pipe"; then
echo
echo "*** However, this would only work if libtool was able to extract symbol"
echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
echo "*** not find such a program. So, this module is probably useless."
echo "*** \`nm' from GNU binutils and a full rebuild may help."
fi
if test "$build_old_libs" = no; then
build_libtool_libs=module
build_old_libs=yes
else
build_libtool_libs=no
fi
fi
else
deplibs="$dir/$old_library $deplibs"
link_static=yes
fi
fi # link shared/static library?
if test "$linkmode" = lib; then
if test -n "$dependency_libs" &&
{ test "$hardcode_into_libs" != yes ||
test "$build_old_libs" = yes ||
test "$link_static" = yes; }; then
# Extract -R from dependency_libs
temp_deplibs=
for libdir in $dependency_libs; do
case $libdir in
-R*) func_stripname '-R' '' "$libdir"
temp_xrpath=$func_stripname_result
case " $xrpath " in
*" $temp_xrpath "*) ;;
*) func_append xrpath " $temp_xrpath";;
esac;;
*) func_append temp_deplibs " $libdir";;
esac
done
dependency_libs="$temp_deplibs"
fi
func_append newlib_search_path " $absdir"
# Link against this library
test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
# ... and its dependency_libs
tmp_libs=
for deplib in $dependency_libs; do
newdependency_libs="$deplib $newdependency_libs"
case $deplib in
-L*) func_stripname '-L' '' "$deplib"
func_resolve_sysroot "$func_stripname_result";;
*) func_resolve_sysroot "$deplib" ;;
esac
if $opt_preserve_dup_deps ; then
case "$tmp_libs " in
*" $func_resolve_sysroot_result "*)
func_append specialdeplibs " $func_resolve_sysroot_result" ;;
esac
fi
func_append tmp_libs " $func_resolve_sysroot_result"
done
if test "$link_all_deplibs" != no; then
# Add the search paths of all dependency libraries
for deplib in $dependency_libs; do
path=
case $deplib in
-L*) path="$deplib" ;;
*.la)
func_resolve_sysroot "$deplib"
deplib=$func_resolve_sysroot_result
func_dirname "$deplib" "" "."
dir=$func_dirname_result
# We need an absolute path.
case $dir in
[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
*)
absdir=`cd "$dir" && pwd`
if test -z "$absdir"; then
func_warning "cannot determine absolute directory name of \`$dir'"
absdir="$dir"
fi
;;
esac
if $GREP "^installed=no" $deplib > /dev/null; then
case $host in
*-*-darwin*)
depdepl=
eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
if test -n "$deplibrary_names" ; then
for tmp in $deplibrary_names ; do
depdepl=$tmp
done
if test -f "$absdir/$objdir/$depdepl" ; then
depdepl="$absdir/$objdir/$depdepl"
darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
if test -z "$darwin_install_name"; then
darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
fi
func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
path=
fi
fi
;;
*)
path="-L$absdir/$objdir"
;;
esac
else
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
test -z "$libdir" && \
func_fatal_error "\`$deplib' is not a valid libtool archive"
test "$absdir" != "$libdir" && \
func_warning "\`$deplib' seems to be moved"
path="-L$absdir"
fi
;;
esac
case " $deplibs " in
*" $path "*) ;;
*) deplibs="$path $deplibs" ;;
esac
done
fi # link_all_deplibs != no
fi # linkmode = lib
done # for deplib in $libs
if test "$pass" = link; then
if test "$linkmode" = "prog"; then
compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
else
compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
fi
fi
dependency_libs="$newdependency_libs"
if test "$pass" = dlpreopen; then
# Link the dlpreopened libraries before other libraries
for deplib in $save_deplibs; do
deplibs="$deplib $deplibs"
done
fi
if test "$pass" != dlopen; then
if test "$pass" != conv; then
# Make sure lib_search_path contains only unique directories.
lib_search_path=
for dir in $newlib_search_path; do
case "$lib_search_path " in
*" $dir "*) ;;
*) func_append lib_search_path " $dir" ;;
esac
done
newlib_search_path=
fi
if test "$linkmode,$pass" != "prog,link"; then
vars="deplibs"
else
vars="compile_deplibs finalize_deplibs"
fi
for var in $vars dependency_libs; do
# Add libraries to $var in reverse order
eval tmp_libs=\"\$$var\"
new_libs=
for deplib in $tmp_libs; do
# FIXME: Pedantically, this is the right thing to do, so
# that some nasty dependency loop isn't accidentally
# broken:
#new_libs="$deplib $new_libs"
# Pragmatically, this seems to cause very few problems in
# practice:
case $deplib in
-L*) new_libs="$deplib $new_libs" ;;
-R*) ;;
*)
# And here is the reason: when a library appears more
# than once as an explicit dependence of a library, or
# is implicitly linked in more than once by the
# compiler, it is considered special, and multiple
# occurrences thereof are not removed. Compare this
# with having the same library being listed as a
# dependency of multiple other libraries: in this case,
# we know (pedantically, we assume) the library does not
# need to be listed more than once, so we keep only the
# last copy. This is not always right, but it is rare
# enough that we require users that really mean to play
# such unportable linking tricks to link the library
# using -Wl,-lname, so that libtool does not consider it
# for duplicate removal.
case " $specialdeplibs " in
*" $deplib "*) new_libs="$deplib $new_libs" ;;
*)
case " $new_libs " in
*" $deplib "*) ;;
*) new_libs="$deplib $new_libs" ;;
esac
;;
esac
;;
esac
done
tmp_libs=
for deplib in $new_libs; do
case $deplib in
-L*)
case " $tmp_libs " in
*" $deplib "*) ;;
*) func_append tmp_libs " $deplib" ;;
esac
;;
*) func_append tmp_libs " $deplib" ;;
esac
done
eval $var=\"$tmp_libs\"
done # for var
fi
# Last step: remove runtime libs from dependency_libs
# (they stay in deplibs)
tmp_libs=
for i in $dependency_libs ; do
case " $predeps $postdeps $compiler_lib_search_path " in
*" $i "*)
i=""
;;
esac
if test -n "$i" ; then
func_append tmp_libs " $i"
fi
done
dependency_libs=$tmp_libs
done # for pass
if test "$linkmode" = prog; then
dlfiles="$newdlfiles"
fi
if test "$linkmode" = prog || test "$linkmode" = lib; then
dlprefiles="$newdlprefiles"
fi
case $linkmode in
oldlib)
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
func_warning "\`-dlopen' is ignored for archives"
fi
case " $deplibs" in
*\ -l* | *\ -L*)
func_warning "\`-l' and \`-L' are ignored for archives" ;;
esac
test -n "$rpath" && \
func_warning "\`-rpath' is ignored for archives"
test -n "$xrpath" && \
func_warning "\`-R' is ignored for archives"
test -n "$vinfo" && \
func_warning "\`-version-info/-version-number' is ignored for archives"
test -n "$release" && \
func_warning "\`-release' is ignored for archives"
test -n "$export_symbols$export_symbols_regex" && \
func_warning "\`-export-symbols' is ignored for archives"
# Now set the variables for building old libraries.
build_libtool_libs=no
oldlibs="$output"
func_append objs "$old_deplibs"
;;
lib)
# Make sure we only generate libraries of the form `libNAME.la'.
case $outputname in
lib*)
func_stripname 'lib' '.la' "$outputname"
name=$func_stripname_result
eval shared_ext=\"$shrext_cmds\"
eval libname=\"$libname_spec\"
;;
*)
test "$module" = no && \
func_fatal_help "libtool library \`$output' must begin with \`lib'"
if test "$need_lib_prefix" != no; then
# Add the "lib" prefix for modules if required
func_stripname '' '.la' "$outputname"
name=$func_stripname_result
eval shared_ext=\"$shrext_cmds\"
eval libname=\"$libname_spec\"
else
func_stripname '' '.la' "$outputname"
libname=$func_stripname_result
fi
;;
esac
if test -n "$objs"; then
if test "$deplibs_check_method" != pass_all; then
func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
else
echo
$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
$ECHO "*** objects $objs is not portable!"
func_append libobjs " $objs"
fi
fi
test "$dlself" != no && \
func_warning "\`-dlopen self' is ignored for libtool libraries"
set dummy $rpath
shift
test "$#" -gt 1 && \
func_warning "ignoring multiple \`-rpath's for a libtool library"
install_libdir="$1"
oldlibs=
if test -z "$rpath"; then
if test "$build_libtool_libs" = yes; then
# Building a libtool convenience library.
# Some compilers have problems with a `.al' extension so
# convenience libraries should have the same extension an
# archive normally would.
oldlibs="$output_objdir/$libname.$libext $oldlibs"
build_libtool_libs=convenience
build_old_libs=yes
fi
test -n "$vinfo" && \
func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
test -n "$release" && \
func_warning "\`-release' is ignored for convenience libraries"
else
# Parse the version information argument.
save_ifs="$IFS"; IFS=':'
set dummy $vinfo 0 0 0
shift
IFS="$save_ifs"
test -n "$7" && \
func_fatal_help "too many parameters to \`-version-info'"
# convert absolute version numbers to libtool ages
# this retains compatibility with .la files and attempts
# to make the code below a bit more comprehensible
case $vinfo_number in
yes)
number_major="$1"
number_minor="$2"
number_revision="$3"
#
# There are really only two kinds -- those that
# use the current revision as the major version
# and those that subtract age and use age as
# a minor version. But, then there is irix
# which has an extra 1 added just for fun
#
case $version_type in
# correct linux to gnu/linux during the next big refactor
darwin|linux|osf|windows|none)
func_arith $number_major + $number_minor
current=$func_arith_result
age="$number_minor"
revision="$number_revision"
;;
freebsd-aout|freebsd-elf|qnx|sunos)
current="$number_major"
revision="$number_minor"
age="0"
;;
irix|nonstopux)
func_arith $number_major + $number_minor
current=$func_arith_result
age="$number_minor"
revision="$number_minor"
lt_irix_increment=no
;;
*)
func_fatal_configuration "$modename: unknown library version type \`$version_type'"
;;
esac
;;
no)
current="$1"
revision="$2"
age="$3"
;;
esac
# Check that each of the things are valid numbers.
case $current in
0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
*)
func_error "CURRENT \`$current' must be a nonnegative integer"
func_fatal_error "\`$vinfo' is not valid version information"
;;
esac
case $revision in
0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
*)
func_error "REVISION \`$revision' must be a nonnegative integer"
func_fatal_error "\`$vinfo' is not valid version information"
;;
esac
case $age in
0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
*)
func_error "AGE \`$age' must be a nonnegative integer"
func_fatal_error "\`$vinfo' is not valid version information"
;;
esac
if test "$age" -gt "$current"; then
func_error "AGE \`$age' is greater than the current interface number \`$current'"
func_fatal_error "\`$vinfo' is not valid version information"
fi
# Calculate the version variables.
major=
versuffix=
verstring=
case $version_type in
none) ;;
darwin)
# Like Linux, but with the current version available in
# verstring for coding it into the library header
func_arith $current - $age
major=.$func_arith_result
versuffix="$major.$age.$revision"
# Darwin ld doesn't like 0 for these options...
func_arith $current + 1
minor_current=$func_arith_result
xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
;;
freebsd-aout)
major=".$current"
versuffix=".$current.$revision";
;;
freebsd-elf)
major=".$current"
versuffix=".$current"
;;
irix | nonstopux)
if test "X$lt_irix_increment" = "Xno"; then
func_arith $current - $age
else
func_arith $current - $age + 1
fi
major=$func_arith_result
case $version_type in
nonstopux) verstring_prefix=nonstopux ;;
*) verstring_prefix=sgi ;;
esac
verstring="$verstring_prefix$major.$revision"
# Add in all the interfaces that we are compatible with.
loop=$revision
while test "$loop" -ne 0; do
func_arith $revision - $loop
iface=$func_arith_result
func_arith $loop - 1
loop=$func_arith_result
verstring="$verstring_prefix$major.$iface:$verstring"
done
# Before this point, $major must not contain `.'.
major=.$major
versuffix="$major.$revision"
;;
linux) # correct to gnu/linux during the next big refactor
func_arith $current - $age
major=.$func_arith_result
versuffix="$major.$age.$revision"
;;
osf)
func_arith $current - $age
major=.$func_arith_result
versuffix=".$current.$age.$revision"
verstring="$current.$age.$revision"
# Add in all the interfaces that we are compatible with.
loop=$age
while test "$loop" -ne 0; do
func_arith $current - $loop
iface=$func_arith_result
func_arith $loop - 1
loop=$func_arith_result
verstring="$verstring:${iface}.0"
done
# Make executables depend on our current version.
func_append verstring ":${current}.0"
;;
qnx)
major=".$current"
versuffix=".$current"
;;
sunos)
major=".$current"
versuffix=".$current.$revision"
;;
windows)
# Use '-' rather than '.', since we only want one
# extension on DOS 8.3 filesystems.
func_arith $current - $age
major=$func_arith_result
versuffix="-$major"
;;
*)
func_fatal_configuration "unknown library version type \`$version_type'"
;;
esac
# Clear the version info if we defaulted, and they specified a release.
if test -z "$vinfo" && test -n "$release"; then
major=
case $version_type in
darwin)
# we can't check for "0.0" in archive_cmds due to quoting
# problems, so we reset it completely
verstring=
;;
*)
verstring="0.0"
;;
esac
if test "$need_version" = no; then
versuffix=
else
versuffix=".0.0"
fi
fi
# Remove version info from name if versioning should be avoided
if test "$avoid_version" = yes && test "$need_version" = no; then
major=
versuffix=
verstring=""
fi
# Check to see if the archive will have undefined symbols.
if test "$allow_undefined" = yes; then
if test "$allow_undefined_flag" = unsupported; then
func_warning "undefined symbols not allowed in $host shared libraries"
build_libtool_libs=no
build_old_libs=yes
fi
else
# Don't allow undefined symbols.
allow_undefined_flag="$no_undefined_flag"
fi
fi
func_generate_dlsyms "$libname" "$libname" "yes"
func_append libobjs " $symfileobj"
test "X$libobjs" = "X " && libobjs=
if test "$opt_mode" != relink; then
# Remove our outputs, but don't remove object files since they
# may have been created when compiling PIC objects.
removelist=
tempremovelist=`$ECHO "$output_objdir/*"`
for p in $tempremovelist; do
case $p in
*.$objext | *.gcno)
;;
$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
if test "X$precious_files_regex" != "X"; then
if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
then
continue
fi
fi
func_append removelist " $p"
;;
*) ;;
esac
done
test -n "$removelist" && \
func_show_eval "${RM}r \$removelist"
fi
# Now set the variables for building old libraries.
if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
func_append oldlibs " $output_objdir/$libname.$libext"
# Transform .lo files to .o files.
oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
fi
# Eliminate all temporary directories.
#for path in $notinst_path; do
# lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
# deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
# dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
#done
if test -n "$xrpath"; then
# If the user specified any rpath flags, then add them.
temp_xrpath=
for libdir in $xrpath; do
func_replace_sysroot "$libdir"
func_append temp_xrpath " -R$func_replace_sysroot_result"
case "$finalize_rpath " in
*" $libdir "*) ;;
*) func_append finalize_rpath " $libdir" ;;
esac
done
if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
dependency_libs="$temp_xrpath $dependency_libs"
fi
fi
# Make sure dlfiles contains only unique files that won't be dlpreopened
old_dlfiles="$dlfiles"
dlfiles=
for lib in $old_dlfiles; do
case " $dlprefiles $dlfiles " in
*" $lib "*) ;;
*) func_append dlfiles " $lib" ;;
esac
done
# Make sure dlprefiles contains only unique files
old_dlprefiles="$dlprefiles"
dlprefiles=
for lib in $old_dlprefiles; do
case "$dlprefiles " in
*" $lib "*) ;;
*) func_append dlprefiles " $lib" ;;
esac
done
if test "$build_libtool_libs" = yes; then
if test -n "$rpath"; then
case $host in
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
# these systems don't actually have a c library (as such)!
;;
*-*-rhapsody* | *-*-darwin1.[012])
# Rhapsody C library is in the System framework
func_append deplibs " System.ltframework"
;;
*-*-netbsd*)
# Don't link with libc until the a.out ld.so is fixed.
;;
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
# Do not include libc due to us having libc/libc_r.
;;
*-*-sco3.2v5* | *-*-sco5v6*)
# Causes problems with __ctype
;;
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
# Compiler inserts libc in the correct place for threads to work
;;
*)
# Add libc to deplibs on all other systems if necessary.
if test "$build_libtool_need_lc" = "yes"; then
func_append deplibs " -lc"
fi
;;
esac
fi
# Transform deplibs into only deplibs that can be linked in shared.
name_save=$name
libname_save=$libname
release_save=$release
versuffix_save=$versuffix
major_save=$major
# I'm not sure if I'm treating the release correctly. I think
# release should show up in the -l (ie -lgmp5) so we don't want to
# add it in twice. Is that correct?
release=""
versuffix=""
major=""
newdeplibs=
droppeddeps=no
case $deplibs_check_method in
pass_all)
# Don't check for shared/static. Everything works.
# This might be a little naive. We might want to check
# whether the library exists or not. But this is on
# osf3 & osf4 and I'm not really sure... Just
# implementing what was already the behavior.
newdeplibs=$deplibs
;;
test_compile)
# This code stresses the "libraries are programs" paradigm to its
# limits. Maybe even breaks it. We compile a program, linking it
# against the deplibs as a proxy for the library. Then we can check
# whether they linked in statically or dynamically with ldd.
$opt_dry_run || $RM conftest.c
cat > conftest.c <<EOF
int main() { return 0; }
EOF
$opt_dry_run || $RM conftest
if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
ldd_output=`ldd conftest`
for i in $deplibs; do
case $i in
-l*)
func_stripname -l '' "$i"
name=$func_stripname_result
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
case " $predeps $postdeps " in
*" $i "*)
func_append newdeplibs " $i"
i=""
;;
esac
fi
if test -n "$i" ; then
libname=`eval "\\$ECHO \"$libname_spec\""`
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
set dummy $deplib_matches; shift
deplib_match=$1
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
func_append newdeplibs " $i"
else
droppeddeps=yes
echo
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
echo "*** I have the capability to make that library automatically link in when"
echo "*** you link to this library. But I can only do this if you have a"
echo "*** shared version of the library, which I believe you do not have"
echo "*** because a test_compile did reveal that the linker did not use it for"
echo "*** its dynamic dependency list that programs get resolved with at runtime."
fi
fi
;;
*)
func_append newdeplibs " $i"
;;
esac
done
else
# Error occurred in the first compile. Let's try to salvage
# the situation: Compile a separate program for each library.
for i in $deplibs; do
case $i in
-l*)
func_stripname -l '' "$i"
name=$func_stripname_result
$opt_dry_run || $RM conftest
if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
ldd_output=`ldd conftest`
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
case " $predeps $postdeps " in
*" $i "*)
func_append newdeplibs " $i"
i=""
;;
esac
fi
if test -n "$i" ; then
libname=`eval "\\$ECHO \"$libname_spec\""`
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
set dummy $deplib_matches; shift
deplib_match=$1
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
func_append newdeplibs " $i"
else
droppeddeps=yes
echo
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
echo "*** I have the capability to make that library automatically link in when"
echo "*** you link to this library. But I can only do this if you have a"
echo "*** shared version of the library, which you do not appear to have"
echo "*** because a test_compile did reveal that the linker did not use this one"
echo "*** as a dynamic dependency that programs can get resolved with at runtime."
fi
fi
else
droppeddeps=yes
echo
$ECHO "*** Warning! Library $i is needed by this library but I was not able to"
echo "*** make it link in! You will probably need to install it or some"
echo "*** library that it depends on before this library will be fully"
echo "*** functional. Installing it before continuing would be even better."
fi
;;
*)
func_append newdeplibs " $i"
;;
esac
done
fi
;;
file_magic*)
set dummy $deplibs_check_method; shift
file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
for a_deplib in $deplibs; do
case $a_deplib in
-l*)
func_stripname -l '' "$a_deplib"
name=$func_stripname_result
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
case " $predeps $postdeps " in
*" $a_deplib "*)
func_append newdeplibs " $a_deplib"
a_deplib=""
;;
esac
fi
if test -n "$a_deplib" ; then
libname=`eval "\\$ECHO \"$libname_spec\""`
if test -n "$file_magic_glob"; then
libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
else
libnameglob=$libname
fi
test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
if test "$want_nocaseglob" = yes; then
shopt -s nocaseglob
potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
$nocaseglob
else
potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
fi
for potent_lib in $potential_libs; do
# Follow soft links.
if ls -lLd "$potent_lib" 2>/dev/null |
$GREP " -> " >/dev/null; then
continue
fi
# The statement above tries to avoid entering an
# endless loop below, in case of cyclic links.
# We might still enter an endless loop, since a link
# loop can be closed while we follow links,
# but so what?
potlib="$potent_lib"
while test -h "$potlib" 2>/dev/null; do
potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
case $potliblink in
[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
esac
done
if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
$SED -e 10q |
$EGREP "$file_magic_regex" > /dev/null; then
func_append newdeplibs " $a_deplib"
a_deplib=""
break 2
fi
done
done
fi
if test -n "$a_deplib" ; then
droppeddeps=yes
echo
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
echo "*** I have the capability to make that library automatically link in when"
echo "*** you link to this library. But I can only do this if you have a"
echo "*** shared version of the library, which you do not appear to have"
echo "*** because I did check the linker path looking for a file starting"
if test -z "$potlib" ; then
$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
else
$ECHO "*** with $libname and none of the candidates passed a file format test"
$ECHO "*** using a file magic. Last file checked: $potlib"
fi
fi
;;
*)
# Add a -L argument.
func_append newdeplibs " $a_deplib"
;;
esac
done # Gone through all deplibs.
;;
match_pattern*)
set dummy $deplibs_check_method; shift
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
for a_deplib in $deplibs; do
case $a_deplib in
-l*)
func_stripname -l '' "$a_deplib"
name=$func_stripname_result
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
case " $predeps $postdeps " in
*" $a_deplib "*)
func_append newdeplibs " $a_deplib"
a_deplib=""
;;
esac
fi
if test -n "$a_deplib" ; then
libname=`eval "\\$ECHO \"$libname_spec\""`
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
for potent_lib in $potential_libs; do
potlib="$potent_lib" # see symlink-check above in file_magic test
if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
$EGREP "$match_pattern_regex" > /dev/null; then
func_append newdeplibs " $a_deplib"
a_deplib=""
break 2
fi
done
done
fi
if test -n "$a_deplib" ; then
droppeddeps=yes
echo
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
echo "*** I have the capability to make that library automatically link in when"
echo "*** you link to this library. But I can only do this if you have a"
echo "*** shared version of the library, which you do not appear to have"
echo "*** because I did check the linker path looking for a file starting"
if test -z "$potlib" ; then
$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
else
$ECHO "*** with $libname and none of the candidates passed a file format test"
$ECHO "*** using a regex pattern. Last file checked: $potlib"
fi
fi
;;
*)
# Add a -L argument.
func_append newdeplibs " $a_deplib"
;;
esac
done # Gone through all deplibs.
;;
none | unknown | *)
newdeplibs=""
tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
for i in $predeps $postdeps ; do
# can't use Xsed below, because $i might contain '/'
tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
done
fi
case $tmp_deplibs in
*[!\ \ ]*)
echo
if test "X$deplibs_check_method" = "Xnone"; then
echo "*** Warning: inter-library dependencies are not supported in this platform."
else
echo "*** Warning: inter-library dependencies are not known to be supported."
fi
echo "*** All declared inter-library dependencies are being dropped."
droppeddeps=yes
;;
esac
;;
esac
versuffix=$versuffix_save
major=$major_save
release=$release_save
libname=$libname_save
name=$name_save
case $host in
*-*-rhapsody* | *-*-darwin1.[012])
# On Rhapsody replace the C library with the System framework
newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
;;
esac
if test "$droppeddeps" = yes; then
if test "$module" = yes; then
echo
echo "*** Warning: libtool could not satisfy all declared inter-library"
$ECHO "*** dependencies of module $libname. Therefore, libtool will create"
echo "*** a static module, that should work as long as the dlopening"
echo "*** application is linked with the -dlopen flag."
if test -z "$global_symbol_pipe"; then
echo
echo "*** However, this would only work if libtool was able to extract symbol"
echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
echo "*** not find such a program. So, this module is probably useless."
echo "*** \`nm' from GNU binutils and a full rebuild may help."
fi
if test "$build_old_libs" = no; then
oldlibs="$output_objdir/$libname.$libext"
build_libtool_libs=module
build_old_libs=yes
else
build_libtool_libs=no
fi
else
echo "*** The inter-library dependencies that have been dropped here will be"
echo "*** automatically added whenever a program is linked with this library"
echo "*** or is declared to -dlopen it."
if test "$allow_undefined" = no; then
echo
echo "*** Since this library must not contain undefined symbols,"
echo "*** because either the platform does not support them or"
echo "*** it was explicitly requested with -no-undefined,"
echo "*** libtool will only create a static version of it."
if test "$build_old_libs" = no; then
oldlibs="$output_objdir/$libname.$libext"
build_libtool_libs=module
build_old_libs=yes
else
build_libtool_libs=no
fi
fi
fi
fi
# Done checking deplibs!
deplibs=$newdeplibs
fi
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
case $host in
*-*-darwin*)
newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
;;
esac
# move library search paths that coincide with paths to not yet
# installed libraries to the beginning of the library search list
new_libs=
for path in $notinst_path; do
case " $new_libs " in
*" -L$path/$objdir "*) ;;
*)
case " $deplibs " in
*" -L$path/$objdir "*)
func_append new_libs " -L$path/$objdir" ;;
esac
;;
esac
done
for deplib in $deplibs; do
case $deplib in
-L*)
case " $new_libs " in
*" $deplib "*) ;;
*) func_append new_libs " $deplib" ;;
esac
;;
*) func_append new_libs " $deplib" ;;
esac
done
deplibs="$new_libs"
# All the library-specific variables (install_libdir is set above).
library_names=
old_library=
dlname=
# Test again, we may have decided not to build it any more
if test "$build_libtool_libs" = yes; then
# Remove ${wl} instances when linking with ld.
# FIXME: should test the right _cmds variable.
case $archive_cmds in
*\$LD\ *) wl= ;;
esac
if test "$hardcode_into_libs" = yes; then
# Hardcode the library paths
hardcode_libdirs=
dep_rpath=
rpath="$finalize_rpath"
test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
for libdir in $rpath; do
if test -n "$hardcode_libdir_flag_spec"; then
if test -n "$hardcode_libdir_separator"; then
func_replace_sysroot "$libdir"
libdir=$func_replace_sysroot_result
if test -z "$hardcode_libdirs"; then
hardcode_libdirs="$libdir"
else
# Just accumulate the unique libdirs.
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
;;
*)
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
;;
esac
fi
else
eval flag=\"$hardcode_libdir_flag_spec\"
func_append dep_rpath " $flag"
fi
elif test -n "$runpath_var"; then
case "$perm_rpath " in
*" $libdir "*) ;;
*) func_append perm_rpath " $libdir" ;;
esac
fi
done
# Substitute the hardcoded libdirs into the rpath.
if test -n "$hardcode_libdir_separator" &&
test -n "$hardcode_libdirs"; then
libdir="$hardcode_libdirs"
eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
fi
if test -n "$runpath_var" && test -n "$perm_rpath"; then
# We should set the runpath_var.
rpath=
for dir in $perm_rpath; do
func_append rpath "$dir:"
done
eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
fi
test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
fi
shlibpath="$finalize_shlibpath"
test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
if test -n "$shlibpath"; then
eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
fi
# Get the real and link names of the library.
eval shared_ext=\"$shrext_cmds\"
eval library_names=\"$library_names_spec\"
set dummy $library_names
shift
realname="$1"
shift
if test -n "$soname_spec"; then
eval soname=\"$soname_spec\"
else
soname="$realname"
fi
if test -z "$dlname"; then
dlname=$soname
fi
lib="$output_objdir/$realname"
linknames=
for link
do
func_append linknames " $link"
done
# Use standard objects if they are pic
test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
test "X$libobjs" = "X " && libobjs=
delfiles=
if test -n "$export_symbols" && test -n "$include_expsyms"; then
$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
export_symbols="$output_objdir/$libname.uexp"
func_append delfiles " $export_symbols"
fi
orig_export_symbols=
case $host_os in
cygwin* | mingw* | cegcc*)
if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
# exporting using user supplied symfile
if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
# and it's NOT already a .def file. Must figure out
# which of the given symbols are data symbols and tag
# them as such. So, trigger use of export_symbols_cmds.
# export_symbols gets reassigned inside the "prepare
# the list of exported symbols" if statement, so the
# include_expsyms logic still works.
orig_export_symbols="$export_symbols"
export_symbols=
always_export_symbols=yes
fi
fi
;;
esac
# Prepare the list of exported symbols
if test -z "$export_symbols"; then
if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
func_verbose "generating symbol list for \`$libname.la'"
export_symbols="$output_objdir/$libname.exp"
$opt_dry_run || $RM $export_symbols
cmds=$export_symbols_cmds
save_ifs="$IFS"; IFS='~'
for cmd1 in $cmds; do
IFS="$save_ifs"
# Take the normal branch if the nm_file_list_spec branch
# doesn't work or if tool conversion is not needed.
case $nm_file_list_spec~$to_tool_file_cmd in
*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
try_normal_branch=yes
eval cmd=\"$cmd1\"
func_len " $cmd"
len=$func_len_result
;;
*)
try_normal_branch=no
;;
esac
if test "$try_normal_branch" = yes \
&& { test "$len" -lt "$max_cmd_len" \
|| test "$max_cmd_len" -le -1; }
then
func_show_eval "$cmd" 'exit $?'
skipped_export=false
elif test -n "$nm_file_list_spec"; then
func_basename "$output"
output_la=$func_basename_result
save_libobjs=$libobjs
save_output=$output
output=${output_objdir}/${output_la}.nm
func_to_tool_file "$output"
libobjs=$nm_file_list_spec$func_to_tool_file_result
func_append delfiles " $output"
func_verbose "creating $NM input file list: $output"
for obj in $save_libobjs; do
func_to_tool_file "$obj"
$ECHO "$func_to_tool_file_result"
done > "$output"
eval cmd=\"$cmd1\"
func_show_eval "$cmd" 'exit $?'
output=$save_output
libobjs=$save_libobjs
skipped_export=false
else
# The command line is too long to execute in one step.
func_verbose "using reloadable object file for export list..."
skipped_export=:
# Break out early, otherwise skipped_export may be
# set to false by a later but shorter cmd.
break
fi
done
IFS="$save_ifs"
if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
fi
fi
fi
if test -n "$export_symbols" && test -n "$include_expsyms"; then
tmp_export_symbols="$export_symbols"
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
fi
if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
# The given exports_symbols file has to be filtered, so filter it.
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
# FIXME: $output_objdir/$libname.filter potentially contains lots of
# 's' commands which not all seds can handle. GNU sed should be fine
# though. Also, the filter scales superlinearly with the number of
# global variables. join(1) would be nice here, but unfortunately
# isn't a blessed tool.
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
func_append delfiles " $export_symbols $output_objdir/$libname.filter"
export_symbols=$output_objdir/$libname.def
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
fi
tmp_deplibs=
for test_deplib in $deplibs; do
case " $convenience " in
*" $test_deplib "*) ;;
*)
func_append tmp_deplibs " $test_deplib"
;;
esac
done
deplibs="$tmp_deplibs"
if test -n "$convenience"; then
if test -n "$whole_archive_flag_spec" &&
test "$compiler_needs_object" = yes &&
test -z "$libobjs"; then
# extract the archives, so we have objects to list.
# TODO: could optimize this to just extract one archive.
whole_archive_flag_spec=
fi
if test -n "$whole_archive_flag_spec"; then
save_libobjs=$libobjs
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
test "X$libobjs" = "X " && libobjs=
else
gentop="$output_objdir/${outputname}x"
func_append generated " $gentop"
func_extract_archives $gentop $convenience
func_append libobjs " $func_extract_archives_result"
test "X$libobjs" = "X " && libobjs=
fi
fi
if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
eval flag=\"$thread_safe_flag_spec\"
func_append linker_flags " $flag"
fi
# Make a backup of the uninstalled library when relinking
if test "$opt_mode" = relink; then
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
fi
# Do each of the archive commands.
if test "$module" = yes && test -n "$module_cmds" ; then
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
eval test_cmds=\"$module_expsym_cmds\"
cmds=$module_expsym_cmds
else
eval test_cmds=\"$module_cmds\"
cmds=$module_cmds
fi
else
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
eval test_cmds=\"$archive_expsym_cmds\"
cmds=$archive_expsym_cmds
else
eval test_cmds=\"$archive_cmds\"
cmds=$archive_cmds
fi
fi
if test "X$skipped_export" != "X:" &&
func_len " $test_cmds" &&
len=$func_len_result &&
test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
:
else
# The command line is too long to link in one step, link piecewise
# or, if using GNU ld and skipped_export is not :, use a linker
# script.
# Save the value of $output and $libobjs because we want to
# use them later. If we have whole_archive_flag_spec, we
# want to use save_libobjs as it was before
# whole_archive_flag_spec was expanded, because we can't
# assume the linker understands whole_archive_flag_spec.
# This may have to be revisited, in case too many
# convenience libraries get linked in and end up exceeding
# the spec.
if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
save_libobjs=$libobjs
fi
save_output=$output
func_basename "$output"
output_la=$func_basename_result
# Clear the reloadable object creation command queue and
# initialize k to one.
test_cmds=
concat_cmds=
objlist=
last_robj=
k=1
if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
output=${output_objdir}/${output_la}.lnkscript
func_verbose "creating GNU ld script: $output"
echo 'INPUT (' > $output
for obj in $save_libobjs
do
func_to_tool_file "$obj"
$ECHO "$func_to_tool_file_result" >> $output
done
echo ')' >> $output
func_append delfiles " $output"
func_to_tool_file "$output"
output=$func_to_tool_file_result
elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
output=${output_objdir}/${output_la}.lnk
func_verbose "creating linker input file list: $output"
: > $output
set x $save_libobjs
shift
firstobj=
if test "$compiler_needs_object" = yes; then
firstobj="$1 "
shift
fi
for obj
do
func_to_tool_file "$obj"
$ECHO "$func_to_tool_file_result" >> $output
done
func_append delfiles " $output"
func_to_tool_file "$output"
output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
else
if test -n "$save_libobjs"; then
func_verbose "creating reloadable object files..."
output=$output_objdir/$output_la-${k}.$objext
eval test_cmds=\"$reload_cmds\"
func_len " $test_cmds"
len0=$func_len_result
len=$len0
# Loop over the list of objects to be linked.
for obj in $save_libobjs
do
func_len " $obj"
func_arith $len + $func_len_result
len=$func_arith_result
if test "X$objlist" = X ||
test "$len" -lt "$max_cmd_len"; then
func_append objlist " $obj"
else
# The command $test_cmds is almost too long, add a
# command to the queue.
if test "$k" -eq 1 ; then
# The first file doesn't have a previous command to add.
reload_objs=$objlist
eval concat_cmds=\"$reload_cmds\"
else
# All subsequent reloadable object files will link in
# the last one created.
reload_objs="$objlist $last_robj"
eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
fi
last_robj=$output_objdir/$output_la-${k}.$objext
func_arith $k + 1
k=$func_arith_result
output=$output_objdir/$output_la-${k}.$objext
objlist=" $obj"
func_len " $last_robj"
func_arith $len0 + $func_len_result
len=$func_arith_result
fi
done
# Handle the remaining objects by creating one last
# reloadable object file. All subsequent reloadable object
# files will link in the last one created.
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
reload_objs="$objlist $last_robj"
eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
if test -n "$last_robj"; then
eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
fi
func_append delfiles " $output"
else
output=
fi
if ${skipped_export-false}; then
func_verbose "generating symbol list for \`$libname.la'"
export_symbols="$output_objdir/$libname.exp"
$opt_dry_run || $RM $export_symbols
libobjs=$output
# Append the command to create the export file.
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
if test -n "$last_robj"; then
eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
fi
fi
test -n "$save_libobjs" &&
func_verbose "creating a temporary reloadable object file: $output"
# Loop through the commands generated above and execute them.
save_ifs="$IFS"; IFS='~'
for cmd in $concat_cmds; do
IFS="$save_ifs"
$opt_silent || {
func_quote_for_expand "$cmd"
eval "func_echo $func_quote_for_expand_result"
}
$opt_dry_run || eval "$cmd" || {
lt_exit=$?
# Restore the uninstalled library and exit
if test "$opt_mode" = relink; then
( cd "$output_objdir" && \
$RM "${realname}T" && \
$MV "${realname}U" "$realname" )
fi
exit $lt_exit
}
done
IFS="$save_ifs"
if test -n "$export_symbols_regex" && ${skipped_export-false}; then
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
fi
fi
if ${skipped_export-false}; then
if test -n "$export_symbols" && test -n "$include_expsyms"; then
tmp_export_symbols="$export_symbols"
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
fi
if test -n "$orig_export_symbols"; then
# The given exports_symbols file has to be filtered, so filter it.
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
# FIXME: $output_objdir/$libname.filter potentially contains lots of
# 's' commands which not all seds can handle. GNU sed should be fine
# though. Also, the filter scales superlinearly with the number of
# global variables. join(1) would be nice here, but unfortunately
# isn't a blessed tool.
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
func_append delfiles " $export_symbols $output_objdir/$libname.filter"
export_symbols=$output_objdir/$libname.def
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
fi
fi
libobjs=$output
# Restore the value of output.
output=$save_output
if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
test "X$libobjs" = "X " && libobjs=
fi
# Expand the library linking commands again to reset the
# value of $libobjs for piecewise linking.
# Do each of the archive commands.
if test "$module" = yes && test -n "$module_cmds" ; then
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
cmds=$module_expsym_cmds
else
cmds=$module_cmds
fi
else
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
cmds=$archive_expsym_cmds
else
cmds=$archive_cmds
fi
fi
fi
if test -n "$delfiles"; then
# Append the command to remove temporary files to $cmds.
eval cmds=\"\$cmds~\$RM $delfiles\"
fi
# Add any objects from preloaded convenience libraries
if test -n "$dlprefiles"; then
gentop="$output_objdir/${outputname}x"
func_append generated " $gentop"
func_extract_archives $gentop $dlprefiles
func_append libobjs " $func_extract_archives_result"
test "X$libobjs" = "X " && libobjs=
fi
save_ifs="$IFS"; IFS='~'
for cmd in $cmds; do
IFS="$save_ifs"
eval cmd=\"$cmd\"
$opt_silent || {
func_quote_for_expand "$cmd"
eval "func_echo $func_quote_for_expand_result"
}
$opt_dry_run || eval "$cmd" || {
lt_exit=$?
# Restore the uninstalled library and exit
if test "$opt_mode" = relink; then
( cd "$output_objdir" && \
$RM "${realname}T" && \
$MV "${realname}U" "$realname" )
fi
exit $lt_exit
}
done
IFS="$save_ifs"
# Restore the uninstalled library and exit
if test "$opt_mode" = relink; then
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
if test -n "$convenience"; then
if test -z "$whole_archive_flag_spec"; then
func_show_eval '${RM}r "$gentop"'
fi
fi
exit $EXIT_SUCCESS
fi
# Create links to the real library.
for linkname in $linknames; do
if test "$realname" != "$linkname"; then
func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
fi
done
# If -module or -export-dynamic was specified, set the dlname.
if test "$module" = yes || test "$export_dynamic" = yes; then
# On all known operating systems, these are identical.
dlname="$soname"
fi
fi
;;
obj)
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
func_warning "\`-dlopen' is ignored for objects"
fi
case " $deplibs" in
*\ -l* | *\ -L*)
func_warning "\`-l' and \`-L' are ignored for objects" ;;
esac
test -n "$rpath" && \
func_warning "\`-rpath' is ignored for objects"
test -n "$xrpath" && \
func_warning "\`-R' is ignored for objects"
test -n "$vinfo" && \
func_warning "\`-version-info' is ignored for objects"
test -n "$release" && \
func_warning "\`-release' is ignored for objects"
case $output in
*.lo)
test -n "$objs$old_deplibs" && \
func_fatal_error "cannot build library object \`$output' from non-libtool objects"
libobj=$output
func_lo2o "$libobj"
obj=$func_lo2o_result
;;
*)
libobj=
obj="$output"
;;
esac
# Delete the old objects.
$opt_dry_run || $RM $obj $libobj
# Objects from convenience libraries. This assumes
# single-version convenience libraries. Whenever we create
# different ones for PIC/non-PIC, this we'll have to duplicate
# the extraction.
reload_conv_objs=
gentop=
# reload_cmds runs $LD directly, so let us get rid of
# -Wl from whole_archive_flag_spec and hope we can get by with
# turning comma into space..
wl=
if test -n "$convenience"; then
if test -n "$whole_archive_flag_spec"; then
eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
else
gentop="$output_objdir/${obj}x"
func_append generated " $gentop"
func_extract_archives $gentop $convenience
reload_conv_objs="$reload_objs $func_extract_archives_result"
fi
fi
# If we're not building shared, we need to use non_pic_objs
test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
# Create the old-style object.
reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
output="$obj"
func_execute_cmds "$reload_cmds" 'exit $?'
# Exit if we aren't doing a library object file.
if test -z "$libobj"; then
if test -n "$gentop"; then
func_show_eval '${RM}r "$gentop"'
fi
exit $EXIT_SUCCESS
fi
if test "$build_libtool_libs" != yes; then
if test -n "$gentop"; then
func_show_eval '${RM}r "$gentop"'
fi
# Create an invalid libtool object if no PIC, so that we don't
# accidentally link it into a program.
# $show "echo timestamp > $libobj"
# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
exit $EXIT_SUCCESS
fi
if test -n "$pic_flag" || test "$pic_mode" != default; then
# Only do commands if we really have different PIC objects.
reload_objs="$libobjs $reload_conv_objs"
output="$libobj"
func_execute_cmds "$reload_cmds" 'exit $?'
fi
if test -n "$gentop"; then
func_show_eval '${RM}r "$gentop"'
fi
exit $EXIT_SUCCESS
;;
prog)
case $host in
*cygwin*) func_stripname '' '.exe' "$output"
output=$func_stripname_result.exe;;
esac
test -n "$vinfo" && \
func_warning "\`-version-info' is ignored for programs"
test -n "$release" && \
func_warning "\`-release' is ignored for programs"
test "$preload" = yes \
&& test "$dlopen_support" = unknown \
&& test "$dlopen_self" = unknown \
&& test "$dlopen_self_static" = unknown && \
func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
case $host in
*-*-rhapsody* | *-*-darwin1.[012])
# On Rhapsody replace the C library is the System framework
compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
;;
esac
case $host in
*-*-darwin*)
# Don't allow lazy linking, it breaks C++ global constructors
# But is supposedly fixed on 10.4 or later (yay!).
if test "$tagname" = CXX ; then
case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
10.[0123])
func_append compile_command " ${wl}-bind_at_load"
func_append finalize_command " ${wl}-bind_at_load"
;;
esac
fi
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
;;
esac
# move library search paths that coincide with paths to not yet
# installed libraries to the beginning of the library search list
new_libs=
for path in $notinst_path; do
case " $new_libs " in
*" -L$path/$objdir "*) ;;
*)
case " $compile_deplibs " in
*" -L$path/$objdir "*)
func_append new_libs " -L$path/$objdir" ;;
esac
;;
esac
done
for deplib in $compile_deplibs; do
case $deplib in
-L*)
case " $new_libs " in
*" $deplib "*) ;;
*) func_append new_libs " $deplib" ;;
esac
;;
*) func_append new_libs " $deplib" ;;
esac
done
compile_deplibs="$new_libs"
func_append compile_command " $compile_deplibs"
func_append finalize_command " $finalize_deplibs"
if test -n "$rpath$xrpath"; then
# If the user specified any rpath flags, then add them.
for libdir in $rpath $xrpath; do
# This is the magic to use -rpath.
case "$finalize_rpath " in
*" $libdir "*) ;;
*) func_append finalize_rpath " $libdir" ;;
esac
done
fi
# Now hardcode the library paths
rpath=
hardcode_libdirs=
for libdir in $compile_rpath $finalize_rpath; do
if test -n "$hardcode_libdir_flag_spec"; then
if test -n "$hardcode_libdir_separator"; then
if test -z "$hardcode_libdirs"; then
hardcode_libdirs="$libdir"
else
# Just accumulate the unique libdirs.
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
;;
*)
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
;;
esac
fi
else
eval flag=\"$hardcode_libdir_flag_spec\"
func_append rpath " $flag"
fi
elif test -n "$runpath_var"; then
case "$perm_rpath " in
*" $libdir "*) ;;
*) func_append perm_rpath " $libdir" ;;
esac
fi
case $host in
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
case :$dllsearchpath: in
*":$libdir:"*) ;;
::) dllsearchpath=$libdir;;
*) func_append dllsearchpath ":$libdir";;
esac
case :$dllsearchpath: in
*":$testbindir:"*) ;;
::) dllsearchpath=$testbindir;;
*) func_append dllsearchpath ":$testbindir";;
esac
;;
esac
done
# Substitute the hardcoded libdirs into the rpath.
if test -n "$hardcode_libdir_separator" &&
test -n "$hardcode_libdirs"; then
libdir="$hardcode_libdirs"
eval rpath=\" $hardcode_libdir_flag_spec\"
fi
compile_rpath="$rpath"
rpath=
hardcode_libdirs=
for libdir in $finalize_rpath; do
if test -n "$hardcode_libdir_flag_spec"; then
if test -n "$hardcode_libdir_separator"; then
if test -z "$hardcode_libdirs"; then
hardcode_libdirs="$libdir"
else
# Just accumulate the unique libdirs.
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
;;
*)
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
;;
esac
fi
else
eval flag=\"$hardcode_libdir_flag_spec\"
func_append rpath " $flag"
fi
elif test -n "$runpath_var"; then
case "$finalize_perm_rpath " in
*" $libdir "*) ;;
*) func_append finalize_perm_rpath " $libdir" ;;
esac
fi
done
# Substitute the hardcoded libdirs into the rpath.
if test -n "$hardcode_libdir_separator" &&
test -n "$hardcode_libdirs"; then
libdir="$hardcode_libdirs"
eval rpath=\" $hardcode_libdir_flag_spec\"
fi
finalize_rpath="$rpath"
if test -n "$libobjs" && test "$build_old_libs" = yes; then
# Transform all the library objects into standard objects.
compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
fi
func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
# template prelinking step
if test -n "$prelink_cmds"; then
func_execute_cmds "$prelink_cmds" 'exit $?'
fi
wrappers_required=yes
case $host in
*cegcc* | *mingw32ce*)
# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
wrappers_required=no
;;
*cygwin* | *mingw* )
if test "$build_libtool_libs" != yes; then
wrappers_required=no
fi
;;
*)
if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
wrappers_required=no
fi
;;
esac
if test "$wrappers_required" = no; then
# Replace the output file specification.
compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
link_command="$compile_command$compile_rpath"
# We have no uninstalled library dependencies, so finalize right now.
exit_status=0
func_show_eval "$link_command" 'exit_status=$?'
if test -n "$postlink_cmds"; then
func_to_tool_file "$output"
postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
func_execute_cmds "$postlink_cmds" 'exit $?'
fi
# Delete the generated files.
if test -f "$output_objdir/${outputname}S.${objext}"; then
func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
fi
exit $exit_status
fi
if test -n "$compile_shlibpath$finalize_shlibpath"; then
compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
fi
if test -n "$finalize_shlibpath"; then
finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
fi
compile_var=
finalize_var=
if test -n "$runpath_var"; then
if test -n "$perm_rpath"; then
# We should set the runpath_var.
rpath=
for dir in $perm_rpath; do
func_append rpath "$dir:"
done
compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
fi
if test -n "$finalize_perm_rpath"; then
# We should set the runpath_var.
rpath=
for dir in $finalize_perm_rpath; do
func_append rpath "$dir:"
done
finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
fi
fi
if test "$no_install" = yes; then
# We don't need to create a wrapper script.
link_command="$compile_var$compile_command$compile_rpath"
# Replace the output file specification.
link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
# Delete the old output file.
$opt_dry_run || $RM $output
# Link the executable and exit
func_show_eval "$link_command" 'exit $?'
if test -n "$postlink_cmds"; then
func_to_tool_file "$output"
postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
func_execute_cmds "$postlink_cmds" 'exit $?'
fi
exit $EXIT_SUCCESS
fi
if test "$hardcode_action" = relink; then
# Fast installation is not supported
link_command="$compile_var$compile_command$compile_rpath"
relink_command="$finalize_var$finalize_command$finalize_rpath"
func_warning "this platform does not like uninstalled shared libraries"
func_warning "\`$output' will be relinked during installation"
else
if test "$fast_install" != no; then
link_command="$finalize_var$compile_command$finalize_rpath"
if test "$fast_install" = yes; then
relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
else
# fast_install is set to needless
relink_command=
fi
else
link_command="$compile_var$compile_command$compile_rpath"
relink_command="$finalize_var$finalize_command$finalize_rpath"
fi
fi
# Replace the output file specification.
link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
# Delete the old output files.
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
func_show_eval "$link_command" 'exit $?'
if test -n "$postlink_cmds"; then
func_to_tool_file "$output_objdir/$outputname"
postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
func_execute_cmds "$postlink_cmds" 'exit $?'
fi
# Now create the wrapper script.
func_verbose "creating $output"
# Quote the relink command for shipping.
if test -n "$relink_command"; then
# Preserve any variables that may affect compiler behavior
for var in $variables_saved_for_relink; do
if eval test -z \"\${$var+set}\"; then
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
elif eval var_value=\$$var; test -z "$var_value"; then
relink_command="$var=; export $var; $relink_command"
else
func_quote_for_eval "$var_value"
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
fi
done
relink_command="(cd `pwd`; $relink_command)"
relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
fi
# Only actually do things if not in dry run mode.
$opt_dry_run || {
# win32 will think the script is a binary if it has
# a .exe suffix, so we strip it off here.
case $output in
*.exe) func_stripname '' '.exe' "$output"
output=$func_stripname_result ;;
esac
# test for cygwin because mv fails w/o .exe extensions
case $host in
*cygwin*)
exeext=.exe
func_stripname '' '.exe' "$outputname"
outputname=$func_stripname_result ;;
*) exeext= ;;
esac
case $host in
*cygwin* | *mingw* )
func_dirname_and_basename "$output" "" "."
output_name=$func_basename_result
output_path=$func_dirname_result
cwrappersource="$output_path/$objdir/lt-$output_name.c"
cwrapper="$output_path/$output_name.exe"
$RM $cwrappersource $cwrapper
trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
func_emit_cwrapperexe_src > $cwrappersource
# The wrapper executable is built using the $host compiler,
# because it contains $host paths and files. If cross-
# compiling, it, like the target executable, must be
# executed on the $host or under an emulation environment.
$opt_dry_run || {
$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
$STRIP $cwrapper
}
# Now, create the wrapper script for func_source use:
func_ltwrapper_scriptname $cwrapper
$RM $func_ltwrapper_scriptname_result
trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
$opt_dry_run || {
# note: this script will not be executed, so do not chmod.
if test "x$build" = "x$host" ; then
$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
else
func_emit_wrapper no > $func_ltwrapper_scriptname_result
fi
}
;;
* )
$RM $output
trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
func_emit_wrapper no > $output
chmod +x $output
;;
esac
}
exit $EXIT_SUCCESS
;;
esac
# See if we need to build an old-fashioned archive.
for oldlib in $oldlibs; do
if test "$build_libtool_libs" = convenience; then
oldobjs="$libobjs_save $symfileobj"
addlibs="$convenience"
build_libtool_libs=no
else
if test "$build_libtool_libs" = module; then
oldobjs="$libobjs_save"
build_libtool_libs=no
else
oldobjs="$old_deplibs $non_pic_objects"
if test "$preload" = yes && test -f "$symfileobj"; then
func_append oldobjs " $symfileobj"
fi
fi
addlibs="$old_convenience"
fi
if test -n "$addlibs"; then
gentop="$output_objdir/${outputname}x"
func_append generated " $gentop"
func_extract_archives $gentop $addlibs
func_append oldobjs " $func_extract_archives_result"
fi
# Do each command in the archive commands.
if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
cmds=$old_archive_from_new_cmds
else
# Add any objects from preloaded convenience libraries
if test -n "$dlprefiles"; then
gentop="$output_objdir/${outputname}x"
func_append generated " $gentop"
func_extract_archives $gentop $dlprefiles
func_append oldobjs " $func_extract_archives_result"
fi
# POSIX demands no paths to be encoded in archives. We have
# to avoid creating archives with duplicate basenames if we
# might have to extract them afterwards, e.g., when creating a
# static archive out of a convenience library, or when linking
# the entirety of a libtool archive into another (currently
# not supported by libtool).
if (for obj in $oldobjs
do
func_basename "$obj"
$ECHO "$func_basename_result"
done | sort | sort -uc >/dev/null 2>&1); then
:
else
echo "copying selected object files to avoid basename conflicts..."
gentop="$output_objdir/${outputname}x"
func_append generated " $gentop"
func_mkdir_p "$gentop"
save_oldobjs=$oldobjs
oldobjs=
counter=1
for obj in $save_oldobjs
do
func_basename "$obj"
objbase="$func_basename_result"
case " $oldobjs " in
" ") oldobjs=$obj ;;
*[\ /]"$objbase "*)
while :; do
# Make sure we don't pick an alternate name that also
# overlaps.
newobj=lt$counter-$objbase
func_arith $counter + 1
counter=$func_arith_result
case " $oldobjs " in
*[\ /]"$newobj "*) ;;
*) if test ! -f "$gentop/$newobj"; then break; fi ;;
esac
done
func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
func_append oldobjs " $gentop/$newobj"
;;
*) func_append oldobjs " $obj" ;;
esac
done
fi
func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
tool_oldlib=$func_to_tool_file_result
eval cmds=\"$old_archive_cmds\"
func_len " $cmds"
len=$func_len_result
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
cmds=$old_archive_cmds
elif test -n "$archiver_list_spec"; then
func_verbose "using command file archive linking..."
for obj in $oldobjs
do
func_to_tool_file "$obj"
$ECHO "$func_to_tool_file_result"
done > $output_objdir/$libname.libcmd
func_to_tool_file "$output_objdir/$libname.libcmd"
oldobjs=" $archiver_list_spec$func_to_tool_file_result"
cmds=$old_archive_cmds
else
# the command line is too long to link in one step, link in parts
func_verbose "using piecewise archive linking..."
save_RANLIB=$RANLIB
RANLIB=:
objlist=
concat_cmds=
save_oldobjs=$oldobjs
oldobjs=
# Is there a better way of finding the last object in the list?
for obj in $save_oldobjs
do
last_oldobj=$obj
done
eval test_cmds=\"$old_archive_cmds\"
func_len " $test_cmds"
len0=$func_len_result
len=$len0
for obj in $save_oldobjs
do
func_len " $obj"
func_arith $len + $func_len_result
len=$func_arith_result
func_append objlist " $obj"
if test "$len" -lt "$max_cmd_len"; then
:
else
# the above command should be used before it gets too long
oldobjs=$objlist
if test "$obj" = "$last_oldobj" ; then
RANLIB=$save_RANLIB
fi
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
objlist=
len=$len0
fi
done
RANLIB=$save_RANLIB
oldobjs=$objlist
if test "X$oldobjs" = "X" ; then
eval cmds=\"\$concat_cmds\"
else
eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
fi
fi
fi
func_execute_cmds "$cmds" 'exit $?'
done
test -n "$generated" && \
func_show_eval "${RM}r$generated"
# Now create the libtool archive.
case $output in
*.la)
old_library=
test "$build_old_libs" = yes && old_library="$libname.$libext"
func_verbose "creating $output"
# Preserve any variables that may affect compiler behavior
for var in $variables_saved_for_relink; do
if eval test -z \"\${$var+set}\"; then
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
elif eval var_value=\$$var; test -z "$var_value"; then
relink_command="$var=; export $var; $relink_command"
else
func_quote_for_eval "$var_value"
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
fi
done
# Quote the link command for shipping.
relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
if test "$hardcode_automatic" = yes ; then
relink_command=
fi
# Only create the output if not a dry run.
$opt_dry_run || {
for installed in no yes; do
if test "$installed" = yes; then
if test -z "$install_libdir"; then
break
fi
output="$output_objdir/$outputname"i
# Replace all uninstalled libtool libraries with the installed ones
newdependency_libs=
for deplib in $dependency_libs; do
case $deplib in
*.la)
func_basename "$deplib"
name="$func_basename_result"
func_resolve_sysroot "$deplib"
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
test -z "$libdir" && \
func_fatal_error "\`$deplib' is not a valid libtool archive"
func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
;;
-L*)
func_stripname -L '' "$deplib"
func_replace_sysroot "$func_stripname_result"
func_append newdependency_libs " -L$func_replace_sysroot_result"
;;
-R*)
func_stripname -R '' "$deplib"
func_replace_sysroot "$func_stripname_result"
func_append newdependency_libs " -R$func_replace_sysroot_result"
;;
*) func_append newdependency_libs " $deplib" ;;
esac
done
dependency_libs="$newdependency_libs"
newdlfiles=
for lib in $dlfiles; do
case $lib in
*.la)
func_basename "$lib"
name="$func_basename_result"
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
test -z "$libdir" && \
func_fatal_error "\`$lib' is not a valid libtool archive"
func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
;;
*) func_append newdlfiles " $lib" ;;
esac
done
dlfiles="$newdlfiles"
newdlprefiles=
for lib in $dlprefiles; do
case $lib in
*.la)
# Only pass preopened files to the pseudo-archive (for
# eventual linking with the app. that links it) if we
# didn't already link the preopened objects directly into
# the library:
func_basename "$lib"
name="$func_basename_result"
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
test -z "$libdir" && \
func_fatal_error "\`$lib' is not a valid libtool archive"
func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
;;
esac
done
dlprefiles="$newdlprefiles"
else
newdlfiles=
for lib in $dlfiles; do
case $lib in
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
*) abs=`pwd`"/$lib" ;;
esac
func_append newdlfiles " $abs"
done
dlfiles="$newdlfiles"
newdlprefiles=
for lib in $dlprefiles; do
case $lib in
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
*) abs=`pwd`"/$lib" ;;
esac
func_append newdlprefiles " $abs"
done
dlprefiles="$newdlprefiles"
fi
$RM $output
# place dlname in correct position for cygwin
# In fact, it would be nice if we could use this code for all target
# systems that can't hard-code library paths into their executables
# and that have no shared library path variable independent of PATH,
# but it turns out we can't easily determine that from inspecting
# libtool variables, so we have to hard-code the OSs to which it
# applies here; at the moment, that means platforms that use the PE
# object format with DLL files. See the long comment at the top of
# tests/bindir.at for full details.
tdlname=$dlname
case $host,$output,$installed,$module,$dlname in
*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
# If a -bindir argument was supplied, place the dll there.
if test "x$bindir" != x ;
then
func_relative_path "$install_libdir" "$bindir"
tdlname=$func_relative_path_result$dlname
else
# Otherwise fall back on heuristic.
tdlname=../bin/$dlname
fi
;;
esac
$ECHO > $output "\
# $outputname - a libtool library file
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
#
# Please DO NOT delete this file!
# It is necessary for linking the library.
# The name that we can dlopen(3).
dlname='$tdlname'
# Names of this library.
library_names='$library_names'
# The name of the static archive.
old_library='$old_library'
# Linker flags that can not go in dependency_libs.
inherited_linker_flags='$new_inherited_linker_flags'
# Libraries that this one depends upon.
dependency_libs='$dependency_libs'
# Names of additional weak libraries provided by this library
weak_library_names='$weak_libs'
# Version information for $libname.
current=$current
age=$age
revision=$revision
# Is this an already installed library?
installed=$installed
# Should we warn about portability when linking against -modules?
shouldnotlink=$module
# Files to dlopen/dlpreopen
dlopen='$dlfiles'
dlpreopen='$dlprefiles'
# Directory that this library needs to be installed in:
libdir='$install_libdir'"
if test "$installed" = no && test "$need_relink" = yes; then
$ECHO >> $output "\
relink_command=\"$relink_command\""
fi
done
}
# Do a symbolic link so that the libtool archive can be found in
# LD_LIBRARY_PATH before the program is installed.
func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
;;
esac
exit $EXIT_SUCCESS
}
{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&
func_mode_link ${1+"$@"}
# func_mode_uninstall arg...
func_mode_uninstall ()
{
$opt_debug
RM="$nonopt"
files=
rmforce=
exit_status=0
# This variable tells wrapper scripts just to set variables rather
# than running their programs.
libtool_install_magic="$magic"
for arg
do
case $arg in
-f) func_append RM " $arg"; rmforce=yes ;;
-*) func_append RM " $arg" ;;
*) func_append files " $arg" ;;
esac
done
test -z "$RM" && \
func_fatal_help "you must specify an RM program"
rmdirs=
for file in $files; do
func_dirname "$file" "" "."
dir="$func_dirname_result"
if test "X$dir" = X.; then
odir="$objdir"
else
odir="$dir/$objdir"
fi
func_basename "$file"
name="$func_basename_result"
test "$opt_mode" = uninstall && odir="$dir"
# Remember odir for removal later, being careful to avoid duplicates
if test "$opt_mode" = clean; then
case " $rmdirs " in
*" $odir "*) ;;
*) func_append rmdirs " $odir" ;;
esac
fi
# Don't error if the file doesn't exist and rm -f was used.
if { test -L "$file"; } >/dev/null 2>&1 ||
{ test -h "$file"; } >/dev/null 2>&1 ||
test -f "$file"; then
:
elif test -d "$file"; then
exit_status=1
continue
elif test "$rmforce" = yes; then
continue
fi
rmfiles="$file"
case $name in
*.la)
# Possibly a libtool archive, so verify it.
if func_lalib_p "$file"; then
func_source $dir/$name
# Delete the libtool libraries and symlinks.
for n in $library_names; do
func_append rmfiles " $odir/$n"
done
test -n "$old_library" && func_append rmfiles " $odir/$old_library"
case "$opt_mode" in
clean)
case " $library_names " in
*" $dlname "*) ;;
*) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
esac
test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
;;
uninstall)
if test -n "$library_names"; then
# Do each command in the postuninstall commands.
func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
fi
if test -n "$old_library"; then
# Do each command in the old_postuninstall commands.
func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
fi
# FIXME: should reinstall the best remaining shared library.
;;
esac
fi
;;
*.lo)
# Possibly a libtool object, so verify it.
if func_lalib_p "$file"; then
# Read the .lo file
func_source $dir/$name
# Add PIC object to the list of files to remove.
if test -n "$pic_object" &&
test "$pic_object" != none; then
func_append rmfiles " $dir/$pic_object"
fi
# Add non-PIC object to the list of files to remove.
if test -n "$non_pic_object" &&
test "$non_pic_object" != none; then
func_append rmfiles " $dir/$non_pic_object"
fi
fi
;;
*)
if test "$opt_mode" = clean ; then
noexename=$name
case $file in
*.exe)
func_stripname '' '.exe' "$file"
file=$func_stripname_result
func_stripname '' '.exe' "$name"
noexename=$func_stripname_result
# $file with .exe has already been added to rmfiles,
# add $file without .exe
func_append rmfiles " $file"
;;
esac
# Do a test to see if this is a libtool program.
if func_ltwrapper_p "$file"; then
if func_ltwrapper_executable_p "$file"; then
func_ltwrapper_scriptname "$file"
relink_command=
func_source $func_ltwrapper_scriptname_result
func_append rmfiles " $func_ltwrapper_scriptname_result"
else
relink_command=
func_source $dir/$noexename
fi
# note $name still contains .exe if it was in $file originally
# as does the version of $file that was added into $rmfiles
func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
if test "$fast_install" = yes && test -n "$relink_command"; then
func_append rmfiles " $odir/lt-$name"
fi
if test "X$noexename" != "X$name" ; then
func_append rmfiles " $odir/lt-${noexename}.c"
fi
fi
fi
;;
esac
func_show_eval "$RM $rmfiles" 'exit_status=1'
done
# Try to remove the ${objdir}s in the directories where we deleted files
for dir in $rmdirs; do
if test -d "$dir"; then
func_show_eval "rmdir $dir >/dev/null 2>&1"
fi
done
exit $exit_status
}
{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
func_mode_uninstall ${1+"$@"}
test -z "$opt_mode" && {
help="$generic_help"
func_fatal_help "you must specify a MODE"
}
test -z "$exec_cmd" && \
func_fatal_help "invalid operation mode \`$opt_mode'"
if test -n "$exec_cmd"; then
eval exec "$exec_cmd"
exit $EXIT_FAILURE
fi
exit $exit_status
# The TAGs below are defined such that we never get into a situation
# in which we disable both kinds of libraries. Given conflicting
# choices, we go for a static library, that is the most portable,
# since we can't tell whether shared libraries were disabled because
# the user asked for that or because the platform doesn't support
# them. This is particularly important on AIX, because we don't
# support having both static and shared libraries enabled at the same
# time on that platform, so we default to a shared-only configuration.
# If a disable-shared tag is given, we'll fallback to a static-only
# configuration. But we'll never go from static-only to shared-only.
# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
build_libtool_libs=no
build_old_libs=yes
# ### END LIBTOOL TAG CONFIG: disable-shared
# ### BEGIN LIBTOOL TAG CONFIG: disable-static
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
# ### END LIBTOOL TAG CONFIG: disable-static
# Local Variables:
# mode:shell-script
# sh-indentation:2
# End:
# vi:sw=2
|
281677160/openwrt-package | 23,566 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/build-aux/depcomp | #! /bin/sh
# depcomp - compile a program generating dependencies as side-effects
scriptversion=2013-05-30.07; # UTC
# Copyright (C) 1999-2013 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.
case $1 in
'')
echo "$0: No command. Try '$0 --help' for more information." 1>&2
exit 1;
;;
-h | --h*)
cat <<\EOF
Usage: depcomp [--help] [--version] PROGRAM [ARGS]
Run PROGRAMS ARGS to compile a file, generating dependencies
as side-effects.
Environment variables:
depmode Dependency tracking mode.
source Source file read by 'PROGRAMS ARGS'.
object Object file output by 'PROGRAMS ARGS'.
DEPDIR directory where to store dependencies.
depfile Dependency file to output.
tmpdepfile Temporary file to use when outputting dependencies.
libtool Whether libtool is used (yes/no).
Report bugs to <bug-automake@gnu.org>.
EOF
exit $?
;;
-v | --v*)
echo "depcomp $scriptversion"
exit $?
;;
esac
# Get the directory component of the given path, and save it in the
# global variables '$dir'. Note that this directory component will
# be either empty or ending with a '/' character. This is deliberate.
set_dir_from ()
{
case $1 in
*/*) dir=`echo "$1" | sed -e 's|/[^/]*$|/|'`;;
*) dir=;;
esac
}
# Get the suffix-stripped basename of the given path, and save it the
# global variable '$base'.
set_base_from ()
{
base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.[^.]*$//'`
}
# If no dependency file was actually created by the compiler invocation,
# we still have to create a dummy depfile, to avoid errors with the
# Makefile "include basename.Plo" scheme.
make_dummy_depfile ()
{
echo "#dummy" > "$depfile"
}
# Factor out some common post-processing of the generated depfile.
# Requires the auxiliary global variable '$tmpdepfile' to be set.
aix_post_process_depfile ()
{
# If the compiler actually managed to produce a dependency file,
# post-process it.
if test -f "$tmpdepfile"; then
# Each line is of the form 'foo.o: dependency.h'.
# Do two passes, one to just change these to
# $object: dependency.h
# and one to simply output
# dependency.h:
# which is needed to avoid the deleted-header problem.
{ sed -e "s,^.*\.[$lower]*:,$object:," < "$tmpdepfile"
sed -e "s,^.*\.[$lower]*:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile"
} > "$depfile"
rm -f "$tmpdepfile"
else
make_dummy_depfile
fi
}
# A tabulation character.
tab=' '
# A newline character.
nl='
'
# Character ranges might be problematic outside the C locale.
# These definitions help.
upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ
lower=abcdefghijklmnopqrstuvwxyz
digits=0123456789
alpha=${upper}${lower}
if test -z "$depmode" || test -z "$source" || test -z "$object"; then
echo "depcomp: Variables source, object and depmode must be set" 1>&2
exit 1
fi
# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
depfile=${depfile-`echo "$object" |
sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
rm -f "$tmpdepfile"
# Avoid interferences from the environment.
gccflag= dashmflag=
# Some modes work just like other modes, but use different flags. We
# parameterize here, but still list the modes in the big case below,
# to make depend.m4 easier to write. Note that we *cannot* use a case
# here, because this file can only contain one case statement.
if test "$depmode" = hp; then
# HP compiler uses -M and no extra arg.
gccflag=-M
depmode=gcc
fi
if test "$depmode" = dashXmstdout; then
# This is just like dashmstdout with a different argument.
dashmflag=-xM
depmode=dashmstdout
fi
cygpath_u="cygpath -u -f -"
if test "$depmode" = msvcmsys; then
# This is just like msvisualcpp but w/o cygpath translation.
# Just convert the backslash-escaped backslashes to single forward
# slashes to satisfy depend.m4
cygpath_u='sed s,\\\\,/,g'
depmode=msvisualcpp
fi
if test "$depmode" = msvc7msys; then
# This is just like msvc7 but w/o cygpath translation.
# Just convert the backslash-escaped backslashes to single forward
# slashes to satisfy depend.m4
cygpath_u='sed s,\\\\,/,g'
depmode=msvc7
fi
if test "$depmode" = xlc; then
# IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information.
gccflag=-qmakedep=gcc,-MF
depmode=gcc
fi
case "$depmode" in
gcc3)
## gcc 3 implements dependency tracking that does exactly what
## we want. Yay! Note: for some reason libtool 1.4 doesn't like
## it if -MD -MP comes after the -MF stuff. Hmm.
## Unfortunately, FreeBSD c89 acceptance of flags depends upon
## the command line argument order; so add the flags where they
## appear in depend2.am. Note that the slowdown incurred here
## affects only configure: in makefiles, %FASTDEP% shortcuts this.
for arg
do
case $arg in
-c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
*) set fnord "$@" "$arg" ;;
esac
shift # fnord
shift # $arg
done
"$@"
stat=$?
if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
mv "$tmpdepfile" "$depfile"
;;
gcc)
## Note that this doesn't just cater to obsosete pre-3.x GCC compilers.
## but also to in-use compilers like IMB xlc/xlC and the HP C compiler.
## (see the conditional assignment to $gccflag above).
## There are various ways to get dependency output from gcc. Here's
## why we pick this rather obscure method:
## - Don't want to use -MD because we'd like the dependencies to end
## up in a subdir. Having to rename by hand is ugly.
## (We might end up doing this anyway to support other compilers.)
## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
## -MM, not -M (despite what the docs say). Also, it might not be
## supported by the other compilers which use the 'gcc' depmode.
## - Using -M directly means running the compiler twice (even worse
## than renaming).
if test -z "$gccflag"; then
gccflag=-MD,
fi
"$@" -Wp,"$gccflag$tmpdepfile"
stat=$?
if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
echo "$object : \\" > "$depfile"
# The second -e expression handles DOS-style file names with drive
# letters.
sed -e 's/^[^:]*: / /' \
-e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
## This next piece of magic avoids the "deleted header file" problem.
## The problem is that when a header file which appears in a .P file
## is deleted, the dependency causes make to die (because there is
## typically no way to rebuild the header). We avoid this by adding
## dummy dependencies for each header file. Too bad gcc doesn't do
## this for us directly.
## Some versions of gcc put a space before the ':'. On the theory
## that the space means something, we add a space to the output as
## well. hp depmode also adds that space, but also prefixes the VPATH
## to the object. Take care to not repeat it in the output.
## Some versions of the HPUX 10.20 sed can't process this invocation
## correctly. Breaking it into two sed invocations is a workaround.
tr ' ' "$nl" < "$tmpdepfile" \
| sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
| sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
hp)
# This case exists only to let depend.m4 do its work. It works by
# looking at the text of this script. This case will never be run,
# since it is checked for above.
exit 1
;;
sgi)
if test "$libtool" = yes; then
"$@" "-Wp,-MDupdate,$tmpdepfile"
else
"$@" -MDupdate "$tmpdepfile"
fi
stat=$?
if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files
echo "$object : \\" > "$depfile"
# Clip off the initial element (the dependent). Don't try to be
# clever and replace this with sed code, as IRIX sed won't handle
# lines with more than a fixed number of characters (4096 in
# IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines;
# the IRIX cc adds comments like '#:fec' to the end of the
# dependency line.
tr ' ' "$nl" < "$tmpdepfile" \
| sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \
| tr "$nl" ' ' >> "$depfile"
echo >> "$depfile"
# The second pass generates a dummy entry for each header file.
tr ' ' "$nl" < "$tmpdepfile" \
| sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
>> "$depfile"
else
make_dummy_depfile
fi
rm -f "$tmpdepfile"
;;
xlc)
# This case exists only to let depend.m4 do its work. It works by
# looking at the text of this script. This case will never be run,
# since it is checked for above.
exit 1
;;
aix)
# The C for AIX Compiler uses -M and outputs the dependencies
# in a .u file. In older versions, this file always lives in the
# current directory. Also, the AIX compiler puts '$object:' at the
# start of each line; $object doesn't have directory information.
# Version 6 uses the directory in both cases.
set_dir_from "$object"
set_base_from "$object"
if test "$libtool" = yes; then
tmpdepfile1=$dir$base.u
tmpdepfile2=$base.u
tmpdepfile3=$dir.libs/$base.u
"$@" -Wc,-M
else
tmpdepfile1=$dir$base.u
tmpdepfile2=$dir$base.u
tmpdepfile3=$dir$base.u
"$@" -M
fi
stat=$?
if test $stat -ne 0; then
rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
exit $stat
fi
for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
do
test -f "$tmpdepfile" && break
done
aix_post_process_depfile
;;
tcc)
# tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26
# FIXME: That version still under development at the moment of writing.
# Make that this statement remains true also for stable, released
# versions.
# It will wrap lines (doesn't matter whether long or short) with a
# trailing '\', as in:
#
# foo.o : \
# foo.c \
# foo.h \
#
# It will put a trailing '\' even on the last line, and will use leading
# spaces rather than leading tabs (at least since its commit 0394caf7
# "Emit spaces for -MD").
"$@" -MD -MF "$tmpdepfile"
stat=$?
if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
# Each non-empty line is of the form 'foo.o : \' or ' dep.h \'.
# We have to change lines of the first kind to '$object: \'.
sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile"
# And for each line of the second kind, we have to emit a 'dep.h:'
# dummy dependency, to avoid the deleted-header problem.
sed -n -e 's|^ *\(.*\) *\\$|\1:|p' < "$tmpdepfile" >> "$depfile"
rm -f "$tmpdepfile"
;;
## The order of this option in the case statement is important, since the
## shell code in configure will try each of these formats in the order
## listed in this file. A plain '-MD' option would be understood by many
## compilers, so we must ensure this comes after the gcc and icc options.
pgcc)
# Portland's C compiler understands '-MD'.
# Will always output deps to 'file.d' where file is the root name of the
# source file under compilation, even if file resides in a subdirectory.
# The object file name does not affect the name of the '.d' file.
# pgcc 10.2 will output
# foo.o: sub/foo.c sub/foo.h
# and will wrap long lines using '\' :
# foo.o: sub/foo.c ... \
# sub/foo.h ... \
# ...
set_dir_from "$object"
# Use the source, not the object, to determine the base name, since
# that's sadly what pgcc will do too.
set_base_from "$source"
tmpdepfile=$base.d
# For projects that build the same source file twice into different object
# files, the pgcc approach of using the *source* file root name can cause
# problems in parallel builds. Use a locking strategy to avoid stomping on
# the same $tmpdepfile.
lockdir=$base.d-lock
trap "
echo '$0: caught signal, cleaning up...' >&2
rmdir '$lockdir'
exit 1
" 1 2 13 15
numtries=100
i=$numtries
while test $i -gt 0; do
# mkdir is a portable test-and-set.
if mkdir "$lockdir" 2>/dev/null; then
# This process acquired the lock.
"$@" -MD
stat=$?
# Release the lock.
rmdir "$lockdir"
break
else
# If the lock is being held by a different process, wait
# until the winning process is done or we timeout.
while test -d "$lockdir" && test $i -gt 0; do
sleep 1
i=`expr $i - 1`
done
fi
i=`expr $i - 1`
done
trap - 1 2 13 15
if test $i -le 0; then
echo "$0: failed to acquire lock after $numtries attempts" >&2
echo "$0: check lockdir '$lockdir'" >&2
exit 1
fi
if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
# Each line is of the form `foo.o: dependent.h',
# or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
# Do two passes, one to just change these to
# `$object: dependent.h' and one to simply `dependent.h:'.
sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
# Some versions of the HPUX 10.20 sed can't process this invocation
# correctly. Breaking it into two sed invocations is a workaround.
sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \
| sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
hp2)
# The "hp" stanza above does not work with aCC (C++) and HP's ia64
# compilers, which have integrated preprocessors. The correct option
# to use with these is +Maked; it writes dependencies to a file named
# 'foo.d', which lands next to the object file, wherever that
# happens to be.
# Much of this is similar to the tru64 case; see comments there.
set_dir_from "$object"
set_base_from "$object"
if test "$libtool" = yes; then
tmpdepfile1=$dir$base.d
tmpdepfile2=$dir.libs/$base.d
"$@" -Wc,+Maked
else
tmpdepfile1=$dir$base.d
tmpdepfile2=$dir$base.d
"$@" +Maked
fi
stat=$?
if test $stat -ne 0; then
rm -f "$tmpdepfile1" "$tmpdepfile2"
exit $stat
fi
for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
do
test -f "$tmpdepfile" && break
done
if test -f "$tmpdepfile"; then
sed -e "s,^.*\.[$lower]*:,$object:," "$tmpdepfile" > "$depfile"
# Add 'dependent.h:' lines.
sed -ne '2,${
s/^ *//
s/ \\*$//
s/$/:/
p
}' "$tmpdepfile" >> "$depfile"
else
make_dummy_depfile
fi
rm -f "$tmpdepfile" "$tmpdepfile2"
;;
tru64)
# The Tru64 compiler uses -MD to generate dependencies as a side
# effect. 'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
# At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
# dependencies in 'foo.d' instead, so we check for that too.
# Subdirectories are respected.
set_dir_from "$object"
set_base_from "$object"
if test "$libtool" = yes; then
# Libtool generates 2 separate objects for the 2 libraries. These
# two compilations output dependencies in $dir.libs/$base.o.d and
# in $dir$base.o.d. We have to check for both files, because
# one of the two compilations can be disabled. We should prefer
# $dir$base.o.d over $dir.libs/$base.o.d because the latter is
# automatically cleaned when .libs/ is deleted, while ignoring
# the former would cause a distcleancheck panic.
tmpdepfile1=$dir$base.o.d # libtool 1.5
tmpdepfile2=$dir.libs/$base.o.d # Likewise.
tmpdepfile3=$dir.libs/$base.d # Compaq CCC V6.2-504
"$@" -Wc,-MD
else
tmpdepfile1=$dir$base.d
tmpdepfile2=$dir$base.d
tmpdepfile3=$dir$base.d
"$@" -MD
fi
stat=$?
if test $stat -ne 0; then
rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
exit $stat
fi
for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
do
test -f "$tmpdepfile" && break
done
# Same post-processing that is required for AIX mode.
aix_post_process_depfile
;;
msvc7)
if test "$libtool" = yes; then
showIncludes=-Wc,-showIncludes
else
showIncludes=-showIncludes
fi
"$@" $showIncludes > "$tmpdepfile"
stat=$?
grep -v '^Note: including file: ' "$tmpdepfile"
if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
echo "$object : \\" > "$depfile"
# The first sed program below extracts the file names and escapes
# backslashes for cygpath. The second sed program outputs the file
# name when reading, but also accumulates all include files in the
# hold buffer in order to output them again at the end. This only
# works with sed implementations that can handle large buffers.
sed < "$tmpdepfile" -n '
/^Note: including file: *\(.*\)/ {
s//\1/
s/\\/\\\\/g
p
}' | $cygpath_u | sort -u | sed -n '
s/ /\\ /g
s/\(.*\)/'"$tab"'\1 \\/p
s/.\(.*\) \\/\1:/
H
$ {
s/.*/'"$tab"'/
G
p
}' >> "$depfile"
echo >> "$depfile" # make sure the fragment doesn't end with a backslash
rm -f "$tmpdepfile"
;;
msvc7msys)
# This case exists only to let depend.m4 do its work. It works by
# looking at the text of this script. This case will never be run,
# since it is checked for above.
exit 1
;;
#nosideeffect)
# This comment above is used by automake to tell side-effect
# dependency tracking mechanisms from slower ones.
dashmstdout)
# Important note: in order to support this mode, a compiler *must*
# always write the preprocessed file to stdout, regardless of -o.
"$@" || exit $?
# Remove the call to Libtool.
if test "$libtool" = yes; then
while test "X$1" != 'X--mode=compile'; do
shift
done
shift
fi
# Remove '-o $object'.
IFS=" "
for arg
do
case $arg in
-o)
shift
;;
$object)
shift
;;
*)
set fnord "$@" "$arg"
shift # fnord
shift # $arg
;;
esac
done
test -z "$dashmflag" && dashmflag=-M
# Require at least two characters before searching for ':'
# in the target name. This is to cope with DOS-style filenames:
# a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
"$@" $dashmflag |
sed "s|^[$tab ]*[^:$tab ][^:][^:]*:[$tab ]*|$object: |" > "$tmpdepfile"
rm -f "$depfile"
cat < "$tmpdepfile" > "$depfile"
# Some versions of the HPUX 10.20 sed can't process this sed invocation
# correctly. Breaking it into two sed invocations is a workaround.
tr ' ' "$nl" < "$tmpdepfile" \
| sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
| sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
dashXmstdout)
# This case only exists to satisfy depend.m4. It is never actually
# run, as this mode is specially recognized in the preamble.
exit 1
;;
makedepend)
"$@" || exit $?
# Remove any Libtool call
if test "$libtool" = yes; then
while test "X$1" != 'X--mode=compile'; do
shift
done
shift
fi
# X makedepend
shift
cleared=no eat=no
for arg
do
case $cleared in
no)
set ""; shift
cleared=yes ;;
esac
if test $eat = yes; then
eat=no
continue
fi
case "$arg" in
-D*|-I*)
set fnord "$@" "$arg"; shift ;;
# Strip any option that makedepend may not understand. Remove
# the object too, otherwise makedepend will parse it as a source file.
-arch)
eat=yes ;;
-*|$object)
;;
*)
set fnord "$@" "$arg"; shift ;;
esac
done
obj_suffix=`echo "$object" | sed 's/^.*\././'`
touch "$tmpdepfile"
${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
rm -f "$depfile"
# makedepend may prepend the VPATH from the source file name to the object.
# No need to regex-escape $object, excess matching of '.' is harmless.
sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile"
# Some versions of the HPUX 10.20 sed can't process the last invocation
# correctly. Breaking it into two sed invocations is a workaround.
sed '1,2d' "$tmpdepfile" \
| tr ' ' "$nl" \
| sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
| sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile" "$tmpdepfile".bak
;;
cpp)
# Important note: in order to support this mode, a compiler *must*
# always write the preprocessed file to stdout.
"$@" || exit $?
# Remove the call to Libtool.
if test "$libtool" = yes; then
while test "X$1" != 'X--mode=compile'; do
shift
done
shift
fi
# Remove '-o $object'.
IFS=" "
for arg
do
case $arg in
-o)
shift
;;
$object)
shift
;;
*)
set fnord "$@" "$arg"
shift # fnord
shift # $arg
;;
esac
done
"$@" -E \
| sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
-e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
| sed '$ s: \\$::' > "$tmpdepfile"
rm -f "$depfile"
echo "$object : \\" > "$depfile"
cat < "$tmpdepfile" >> "$depfile"
sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
msvisualcpp)
# Important note: in order to support this mode, a compiler *must*
# always write the preprocessed file to stdout.
"$@" || exit $?
# Remove the call to Libtool.
if test "$libtool" = yes; then
while test "X$1" != 'X--mode=compile'; do
shift
done
shift
fi
IFS=" "
for arg
do
case "$arg" in
-o)
shift
;;
$object)
shift
;;
"-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
set fnord "$@"
shift
shift
;;
*)
set fnord "$@" "$arg"
shift
shift
;;
esac
done
"$@" -E 2>/dev/null |
sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
rm -f "$depfile"
echo "$object : \\" > "$depfile"
sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile"
echo "$tab" >> "$depfile"
sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
rm -f "$tmpdepfile"
;;
msvcmsys)
# This case exists only to let depend.m4 do its work. It works by
# looking at the text of this script. This case will never be run,
# since it is checked for above.
exit 1
;;
none)
exec "$@"
;;
*)
echo "Unknown depmode $depmode" 1>&2
exit 1
;;
esac
exit 0
# Local Variables:
# mode: shell-script
# sh-indentation: 2
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC"
# time-stamp-end: "; # UTC"
# End:
|
281677160/openwrt-package | 45,297 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/build-aux/config.guess | #! /bin/sh
# Attempt to guess a canonical system name.
# Copyright 1992-2013 Free Software Foundation, Inc.
timestamp='2013-06-10'
# This file is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that
# program. This Exception is an additional permission under section 7
# of the GNU General Public License, version 3 ("GPLv3").
#
# Originally written by Per Bothner.
#
# You can get the latest version of this script from:
# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
#
# Please send patches with a ChangeLog entry to config-patches@gnu.org.
me=`echo "$0" | sed -e 's,.*/,,'`
usage="\
Usage: $0 [OPTION]
Output the configuration name of the system \`$me' is run on.
Operation modes:
-h, --help print this help, then exit
-t, --time-stamp print date of last modification, then exit
-v, --version print version number, then exit
Report bugs and patches to <config-patches@gnu.org>."
version="\
GNU config.guess ($timestamp)
Originally written by Per Bothner.
Copyright 1992-2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
help="
Try \`$me --help' for more information."
# Parse command line
while test $# -gt 0 ; do
case $1 in
--time-stamp | --time* | -t )
echo "$timestamp" ; exit ;;
--version | -v )
echo "$version" ; exit ;;
--help | --h* | -h )
echo "$usage"; exit ;;
-- ) # Stop option processing
shift; break ;;
- ) # Use stdin as input.
break ;;
-* )
echo "$me: invalid option $1$help" >&2
exit 1 ;;
* )
break ;;
esac
done
if test $# != 0; then
echo "$me: too many arguments$help" >&2
exit 1
fi
trap 'exit 1' 1 2 15
# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
# compiler to aid in system detection is discouraged as it requires
# temporary files to be created and, as you can see below, it is a
# headache to deal with in a portable fashion.
# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
# use `HOST_CC' if defined, but it is deprecated.
# Portable tmp directory creation inspired by the Autoconf team.
set_cc_for_build='
trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
: ${TMPDIR=/tmp} ;
{ tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
{ test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
{ tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
{ echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
dummy=$tmp/dummy ;
tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
case $CC_FOR_BUILD,$HOST_CC,$CC in
,,) echo "int x;" > $dummy.c ;
for c in cc gcc c89 c99 ; do
if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
CC_FOR_BUILD="$c"; break ;
fi ;
done ;
if test x"$CC_FOR_BUILD" = x ; then
CC_FOR_BUILD=no_compiler_found ;
fi
;;
,,*) CC_FOR_BUILD=$CC ;;
,*,*) CC_FOR_BUILD=$HOST_CC ;;
esac ; set_cc_for_build= ;'
# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
# (ghazi@noc.rutgers.edu 1994-08-24)
if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
PATH=$PATH:/.attbin ; export PATH
fi
UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
case "${UNAME_SYSTEM}" in
Linux|GNU|GNU/*)
# If the system lacks a compiler, then just pick glibc.
# We could probably try harder.
LIBC=gnu
eval $set_cc_for_build
cat <<-EOF > $dummy.c
#include <features.h>
#if defined(__UCLIBC__)
LIBC=uclibc
#elif defined(__dietlibc__)
LIBC=dietlibc
#else
LIBC=gnu
#endif
EOF
eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'`
;;
esac
# Note: order is significant - the case branches are not exclusive.
case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
*:NetBSD:*:*)
# NetBSD (nbsd) targets should (where applicable) match one or
# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
# *-*-netbsdecoff* and *-*-netbsd*. For targets that recently
# switched to ELF, *-*-netbsd* would select the old
# object file format. This provides both forward
# compatibility and a consistent mechanism for selecting the
# object file format.
#
# Note: NetBSD doesn't particularly care about the vendor
# portion of the name. We always set it to "unknown".
sysctl="sysctl -n hw.machine_arch"
UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \
/usr/sbin/$sysctl 2>/dev/null || echo unknown)`
case "${UNAME_MACHINE_ARCH}" in
armeb) machine=armeb-unknown ;;
arm*) machine=arm-unknown ;;
sh3el) machine=shl-unknown ;;
sh3eb) machine=sh-unknown ;;
sh5el) machine=sh5le-unknown ;;
*) machine=${UNAME_MACHINE_ARCH}-unknown ;;
esac
# The Operating System including object format, if it has switched
# to ELF recently, or will in the future.
case "${UNAME_MACHINE_ARCH}" in
arm*|i386|m68k|ns32k|sh3*|sparc|vax)
eval $set_cc_for_build
if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
| grep -q __ELF__
then
# Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
# Return netbsd for either. FIX?
os=netbsd
else
os=netbsdelf
fi
;;
*)
os=netbsd
;;
esac
# The OS release
# Debian GNU/NetBSD machines have a different userland, and
# thus, need a distinct triplet. However, they do not need
# kernel version information, so it can be replaced with a
# suitable tag, in the style of linux-gnu.
case "${UNAME_VERSION}" in
Debian*)
release='-gnu'
;;
*)
release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
;;
esac
# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
# contains redundant information, the shorter form:
# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
echo "${machine}-${os}${release}"
exit ;;
*:Bitrig:*:*)
UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE}
exit ;;
*:OpenBSD:*:*)
UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
exit ;;
*:ekkoBSD:*:*)
echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
exit ;;
*:SolidBSD:*:*)
echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
exit ;;
macppc:MirBSD:*:*)
echo powerpc-unknown-mirbsd${UNAME_RELEASE}
exit ;;
*:MirBSD:*:*)
echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
exit ;;
alpha:OSF1:*:*)
case $UNAME_RELEASE in
*4.0)
UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
;;
*5.*)
UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
;;
esac
# According to Compaq, /usr/sbin/psrinfo has been available on
# OSF/1 and Tru64 systems produced since 1995. I hope that
# covers most systems running today. This code pipes the CPU
# types through head -n 1, so we only detect the type of CPU 0.
ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1`
case "$ALPHA_CPU_TYPE" in
"EV4 (21064)")
UNAME_MACHINE="alpha" ;;
"EV4.5 (21064)")
UNAME_MACHINE="alpha" ;;
"LCA4 (21066/21068)")
UNAME_MACHINE="alpha" ;;
"EV5 (21164)")
UNAME_MACHINE="alphaev5" ;;
"EV5.6 (21164A)")
UNAME_MACHINE="alphaev56" ;;
"EV5.6 (21164PC)")
UNAME_MACHINE="alphapca56" ;;
"EV5.7 (21164PC)")
UNAME_MACHINE="alphapca57" ;;
"EV6 (21264)")
UNAME_MACHINE="alphaev6" ;;
"EV6.7 (21264A)")
UNAME_MACHINE="alphaev67" ;;
"EV6.8CB (21264C)")
UNAME_MACHINE="alphaev68" ;;
"EV6.8AL (21264B)")
UNAME_MACHINE="alphaev68" ;;
"EV6.8CX (21264D)")
UNAME_MACHINE="alphaev68" ;;
"EV6.9A (21264/EV69A)")
UNAME_MACHINE="alphaev69" ;;
"EV7 (21364)")
UNAME_MACHINE="alphaev7" ;;
"EV7.9 (21364A)")
UNAME_MACHINE="alphaev79" ;;
esac
# A Pn.n version is a patched version.
# A Vn.n version is a released version.
# A Tn.n version is a released field test version.
# A Xn.n version is an unreleased experimental baselevel.
# 1.2 uses "1.2" for uname -r.
echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
exitcode=$?
trap '' 0
exit $exitcode ;;
Alpha\ *:Windows_NT*:*)
# How do we know it's Interix rather than the generic POSIX subsystem?
# Should we change UNAME_MACHINE based on the output of uname instead
# of the specific Alpha model?
echo alpha-pc-interix
exit ;;
21064:Windows_NT:50:3)
echo alpha-dec-winnt3.5
exit ;;
Amiga*:UNIX_System_V:4.0:*)
echo m68k-unknown-sysv4
exit ;;
*:[Aa]miga[Oo][Ss]:*:*)
echo ${UNAME_MACHINE}-unknown-amigaos
exit ;;
*:[Mm]orph[Oo][Ss]:*:*)
echo ${UNAME_MACHINE}-unknown-morphos
exit ;;
*:OS/390:*:*)
echo i370-ibm-openedition
exit ;;
*:z/VM:*:*)
echo s390-ibm-zvmoe
exit ;;
*:OS400:*:*)
echo powerpc-ibm-os400
exit ;;
arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
echo arm-acorn-riscix${UNAME_RELEASE}
exit ;;
arm*:riscos:*:*|arm*:RISCOS:*:*)
echo arm-unknown-riscos
exit ;;
SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
echo hppa1.1-hitachi-hiuxmpp
exit ;;
Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
if test "`(/bin/universe) 2>/dev/null`" = att ; then
echo pyramid-pyramid-sysv3
else
echo pyramid-pyramid-bsd
fi
exit ;;
NILE*:*:*:dcosx)
echo pyramid-pyramid-svr4
exit ;;
DRS?6000:unix:4.0:6*)
echo sparc-icl-nx6
exit ;;
DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
case `/usr/bin/uname -p` in
sparc) echo sparc-icl-nx7; exit ;;
esac ;;
s390x:SunOS:*:*)
echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
exit ;;
sun4H:SunOS:5.*:*)
echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
exit ;;
sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
exit ;;
i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
echo i386-pc-auroraux${UNAME_RELEASE}
exit ;;
i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
eval $set_cc_for_build
SUN_ARCH="i386"
# If there is a compiler, see if it is configured for 64-bit objects.
# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
# This test works for both compilers.
if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
grep IS_64BIT_ARCH >/dev/null
then
SUN_ARCH="x86_64"
fi
fi
echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
exit ;;
sun4*:SunOS:6*:*)
# According to config.sub, this is the proper way to canonicalize
# SunOS6. Hard to guess exactly what SunOS6 will be like, but
# it's likely to be more like Solaris than SunOS4.
echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
exit ;;
sun4*:SunOS:*:*)
case "`/usr/bin/arch -k`" in
Series*|S4*)
UNAME_RELEASE=`uname -v`
;;
esac
# Japanese Language versions have a version number like `4.1.3-JL'.
echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
exit ;;
sun3*:SunOS:*:*)
echo m68k-sun-sunos${UNAME_RELEASE}
exit ;;
sun*:*:4.2BSD:*)
UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
case "`/bin/arch`" in
sun3)
echo m68k-sun-sunos${UNAME_RELEASE}
;;
sun4)
echo sparc-sun-sunos${UNAME_RELEASE}
;;
esac
exit ;;
aushp:SunOS:*:*)
echo sparc-auspex-sunos${UNAME_RELEASE}
exit ;;
# The situation for MiNT is a little confusing. The machine name
# can be virtually everything (everything which is not
# "atarist" or "atariste" at least should have a processor
# > m68000). The system name ranges from "MiNT" over "FreeMiNT"
# to the lowercase version "mint" (or "freemint"). Finally
# the system name "TOS" denotes a system which is actually not
# MiNT. But MiNT is downward compatible to TOS, so this should
# be no problem.
atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
echo m68k-atari-mint${UNAME_RELEASE}
exit ;;
atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
echo m68k-atari-mint${UNAME_RELEASE}
exit ;;
*falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
echo m68k-atari-mint${UNAME_RELEASE}
exit ;;
milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
echo m68k-milan-mint${UNAME_RELEASE}
exit ;;
hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
echo m68k-hades-mint${UNAME_RELEASE}
exit ;;
*:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
echo m68k-unknown-mint${UNAME_RELEASE}
exit ;;
m68k:machten:*:*)
echo m68k-apple-machten${UNAME_RELEASE}
exit ;;
powerpc:machten:*:*)
echo powerpc-apple-machten${UNAME_RELEASE}
exit ;;
RISC*:Mach:*:*)
echo mips-dec-mach_bsd4.3
exit ;;
RISC*:ULTRIX:*:*)
echo mips-dec-ultrix${UNAME_RELEASE}
exit ;;
VAX*:ULTRIX*:*:*)
echo vax-dec-ultrix${UNAME_RELEASE}
exit ;;
2020:CLIX:*:* | 2430:CLIX:*:*)
echo clipper-intergraph-clix${UNAME_RELEASE}
exit ;;
mips:*:*:UMIPS | mips:*:*:RISCos)
eval $set_cc_for_build
sed 's/^ //' << EOF >$dummy.c
#ifdef __cplusplus
#include <stdio.h> /* for printf() prototype */
int main (int argc, char *argv[]) {
#else
int main (argc, argv) int argc; char *argv[]; {
#endif
#if defined (host_mips) && defined (MIPSEB)
#if defined (SYSTYPE_SYSV)
printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
#endif
#if defined (SYSTYPE_SVR4)
printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
#endif
#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
#endif
#endif
exit (-1);
}
EOF
$CC_FOR_BUILD -o $dummy $dummy.c &&
dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` &&
SYSTEM_NAME=`$dummy $dummyarg` &&
{ echo "$SYSTEM_NAME"; exit; }
echo mips-mips-riscos${UNAME_RELEASE}
exit ;;
Motorola:PowerMAX_OS:*:*)
echo powerpc-motorola-powermax
exit ;;
Motorola:*:4.3:PL8-*)
echo powerpc-harris-powermax
exit ;;
Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
echo powerpc-harris-powermax
exit ;;
Night_Hawk:Power_UNIX:*:*)
echo powerpc-harris-powerunix
exit ;;
m88k:CX/UX:7*:*)
echo m88k-harris-cxux7
exit ;;
m88k:*:4*:R4*)
echo m88k-motorola-sysv4
exit ;;
m88k:*:3*:R3*)
echo m88k-motorola-sysv3
exit ;;
AViiON:dgux:*:*)
# DG/UX returns AViiON for all architectures
UNAME_PROCESSOR=`/usr/bin/uname -p`
if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
then
if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
[ ${TARGET_BINARY_INTERFACE}x = x ]
then
echo m88k-dg-dgux${UNAME_RELEASE}
else
echo m88k-dg-dguxbcs${UNAME_RELEASE}
fi
else
echo i586-dg-dgux${UNAME_RELEASE}
fi
exit ;;
M88*:DolphinOS:*:*) # DolphinOS (SVR3)
echo m88k-dolphin-sysv3
exit ;;
M88*:*:R3*:*)
# Delta 88k system running SVR3
echo m88k-motorola-sysv3
exit ;;
XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
echo m88k-tektronix-sysv3
exit ;;
Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
echo m68k-tektronix-bsd
exit ;;
*:IRIX*:*:*)
echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
exit ;;
????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id
exit ;; # Note that: echo "'`uname -s`'" gives 'AIX '
i*86:AIX:*:*)
echo i386-ibm-aix
exit ;;
ia64:AIX:*:*)
if [ -x /usr/bin/oslevel ] ; then
IBM_REV=`/usr/bin/oslevel`
else
IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
fi
echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
exit ;;
*:AIX:2:3)
if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
eval $set_cc_for_build
sed 's/^ //' << EOF >$dummy.c
#include <sys/systemcfg.h>
main()
{
if (!__power_pc())
exit(1);
puts("powerpc-ibm-aix3.2.5");
exit(0);
}
EOF
if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
then
echo "$SYSTEM_NAME"
else
echo rs6000-ibm-aix3.2.5
fi
elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
echo rs6000-ibm-aix3.2.4
else
echo rs6000-ibm-aix3.2
fi
exit ;;
*:AIX:*:[4567])
IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
IBM_ARCH=rs6000
else
IBM_ARCH=powerpc
fi
if [ -x /usr/bin/oslevel ] ; then
IBM_REV=`/usr/bin/oslevel`
else
IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
fi
echo ${IBM_ARCH}-ibm-aix${IBM_REV}
exit ;;
*:AIX:*:*)
echo rs6000-ibm-aix
exit ;;
ibmrt:4.4BSD:*|romp-ibm:BSD:*)
echo romp-ibm-bsd4.4
exit ;;
ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and
echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to
exit ;; # report: romp-ibm BSD 4.3
*:BOSX:*:*)
echo rs6000-bull-bosx
exit ;;
DPX/2?00:B.O.S.:*:*)
echo m68k-bull-sysv3
exit ;;
9000/[34]??:4.3bsd:1.*:*)
echo m68k-hp-bsd
exit ;;
hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
echo m68k-hp-bsd4.4
exit ;;
9000/[34678]??:HP-UX:*:*)
HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
case "${UNAME_MACHINE}" in
9000/31? ) HP_ARCH=m68000 ;;
9000/[34]?? ) HP_ARCH=m68k ;;
9000/[678][0-9][0-9])
if [ -x /usr/bin/getconf ]; then
sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
case "${sc_cpu_version}" in
523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
532) # CPU_PA_RISC2_0
case "${sc_kernel_bits}" in
32) HP_ARCH="hppa2.0n" ;;
64) HP_ARCH="hppa2.0w" ;;
'') HP_ARCH="hppa2.0" ;; # HP-UX 10.20
esac ;;
esac
fi
if [ "${HP_ARCH}" = "" ]; then
eval $set_cc_for_build
sed 's/^ //' << EOF >$dummy.c
#define _HPUX_SOURCE
#include <stdlib.h>
#include <unistd.h>
int main ()
{
#if defined(_SC_KERNEL_BITS)
long bits = sysconf(_SC_KERNEL_BITS);
#endif
long cpu = sysconf (_SC_CPU_VERSION);
switch (cpu)
{
case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
case CPU_PA_RISC2_0:
#if defined(_SC_KERNEL_BITS)
switch (bits)
{
case 64: puts ("hppa2.0w"); break;
case 32: puts ("hppa2.0n"); break;
default: puts ("hppa2.0"); break;
} break;
#else /* !defined(_SC_KERNEL_BITS) */
puts ("hppa2.0"); break;
#endif
default: puts ("hppa1.0"); break;
}
exit (0);
}
EOF
(CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
test -z "$HP_ARCH" && HP_ARCH=hppa
fi ;;
esac
if [ ${HP_ARCH} = "hppa2.0w" ]
then
eval $set_cc_for_build
# hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
# 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler
# generating 64-bit code. GNU and HP use different nomenclature:
#
# $ CC_FOR_BUILD=cc ./config.guess
# => hppa2.0w-hp-hpux11.23
# $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
# => hppa64-hp-hpux11.23
if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |
grep -q __LP64__
then
HP_ARCH="hppa2.0w"
else
HP_ARCH="hppa64"
fi
fi
echo ${HP_ARCH}-hp-hpux${HPUX_REV}
exit ;;
ia64:HP-UX:*:*)
HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
echo ia64-hp-hpux${HPUX_REV}
exit ;;
3050*:HI-UX:*:*)
eval $set_cc_for_build
sed 's/^ //' << EOF >$dummy.c
#include <unistd.h>
int
main ()
{
long cpu = sysconf (_SC_CPU_VERSION);
/* The order matters, because CPU_IS_HP_MC68K erroneously returns
true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct
results, however. */
if (CPU_IS_PA_RISC (cpu))
{
switch (cpu)
{
case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
default: puts ("hppa-hitachi-hiuxwe2"); break;
}
}
else if (CPU_IS_HP_MC68K (cpu))
puts ("m68k-hitachi-hiuxwe2");
else puts ("unknown-hitachi-hiuxwe2");
exit (0);
}
EOF
$CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
{ echo "$SYSTEM_NAME"; exit; }
echo unknown-hitachi-hiuxwe2
exit ;;
9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
echo hppa1.1-hp-bsd
exit ;;
9000/8??:4.3bsd:*:*)
echo hppa1.0-hp-bsd
exit ;;
*9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
echo hppa1.0-hp-mpeix
exit ;;
hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
echo hppa1.1-hp-osf
exit ;;
hp8??:OSF1:*:*)
echo hppa1.0-hp-osf
exit ;;
i*86:OSF1:*:*)
if [ -x /usr/sbin/sysversion ] ; then
echo ${UNAME_MACHINE}-unknown-osf1mk
else
echo ${UNAME_MACHINE}-unknown-osf1
fi
exit ;;
parisc*:Lites*:*:*)
echo hppa1.1-hp-lites
exit ;;
C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
echo c1-convex-bsd
exit ;;
C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
if getsysinfo -f scalar_acc
then echo c32-convex-bsd
else echo c2-convex-bsd
fi
exit ;;
C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
echo c34-convex-bsd
exit ;;
C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
echo c38-convex-bsd
exit ;;
C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
echo c4-convex-bsd
exit ;;
CRAY*Y-MP:*:*:*)
echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
exit ;;
CRAY*[A-Z]90:*:*:*)
echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
-e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
-e 's/\.[^.]*$/.X/'
exit ;;
CRAY*TS:*:*:*)
echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
exit ;;
CRAY*T3E:*:*:*)
echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
exit ;;
CRAY*SV1:*:*:*)
echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
exit ;;
*:UNICOS/mp:*:*)
echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
exit ;;
F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
exit ;;
5000:UNIX_System_V:4.*:*)
FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
exit ;;
i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
exit ;;
sparc*:BSD/OS:*:*)
echo sparc-unknown-bsdi${UNAME_RELEASE}
exit ;;
*:BSD/OS:*:*)
echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
exit ;;
*:FreeBSD:*:*)
UNAME_PROCESSOR=`/usr/bin/uname -p`
case ${UNAME_PROCESSOR} in
amd64)
echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
*)
echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
esac
exit ;;
i*:CYGWIN*:*)
echo ${UNAME_MACHINE}-pc-cygwin
exit ;;
*:MINGW64*:*)
echo ${UNAME_MACHINE}-pc-mingw64
exit ;;
*:MINGW*:*)
echo ${UNAME_MACHINE}-pc-mingw32
exit ;;
i*:MSYS*:*)
echo ${UNAME_MACHINE}-pc-msys
exit ;;
i*:windows32*:*)
# uname -m includes "-pc" on this system.
echo ${UNAME_MACHINE}-mingw32
exit ;;
i*:PW*:*)
echo ${UNAME_MACHINE}-pc-pw32
exit ;;
*:Interix*:*)
case ${UNAME_MACHINE} in
x86)
echo i586-pc-interix${UNAME_RELEASE}
exit ;;
authenticamd | genuineintel | EM64T)
echo x86_64-unknown-interix${UNAME_RELEASE}
exit ;;
IA64)
echo ia64-unknown-interix${UNAME_RELEASE}
exit ;;
esac ;;
[345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
echo i${UNAME_MACHINE}-pc-mks
exit ;;
8664:Windows_NT:*)
echo x86_64-pc-mks
exit ;;
i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
# How do we know it's Interix rather than the generic POSIX subsystem?
# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
# UNAME_MACHINE based on the output of uname instead of i386?
echo i586-pc-interix
exit ;;
i*:UWIN*:*)
echo ${UNAME_MACHINE}-pc-uwin
exit ;;
amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
echo x86_64-unknown-cygwin
exit ;;
p*:CYGWIN*:*)
echo powerpcle-unknown-cygwin
exit ;;
prep*:SunOS:5.*:*)
echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
exit ;;
*:GNU:*:*)
# the GNU system
echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
exit ;;
*:GNU/*:*:*)
# other systems with GNU libc and userland
echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-${LIBC}
exit ;;
i*86:Minix:*:*)
echo ${UNAME_MACHINE}-pc-minix
exit ;;
aarch64:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
aarch64_be:Linux:*:*)
UNAME_MACHINE=aarch64_be
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
alpha:Linux:*:*)
case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
EV5) UNAME_MACHINE=alphaev5 ;;
EV56) UNAME_MACHINE=alphaev56 ;;
PCA56) UNAME_MACHINE=alphapca56 ;;
PCA57) UNAME_MACHINE=alphapca56 ;;
EV6) UNAME_MACHINE=alphaev6 ;;
EV67) UNAME_MACHINE=alphaev67 ;;
EV68*) UNAME_MACHINE=alphaev68 ;;
esac
objdump --private-headers /bin/sh | grep -q ld.so.1
if test "$?" = 0 ; then LIBC="gnulibc1" ; fi
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
arc:Linux:*:* | arceb:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
arm*:Linux:*:*)
eval $set_cc_for_build
if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
| grep -q __ARM_EABI__
then
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
else
if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
| grep -q __ARM_PCS_VFP
then
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi
else
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf
fi
fi
exit ;;
avr32*:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
cris:Linux:*:*)
echo ${UNAME_MACHINE}-axis-linux-${LIBC}
exit ;;
crisv32:Linux:*:*)
echo ${UNAME_MACHINE}-axis-linux-${LIBC}
exit ;;
frv:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
hexagon:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
i*86:Linux:*:*)
echo ${UNAME_MACHINE}-pc-linux-${LIBC}
exit ;;
ia64:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
m32r*:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
m68*:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
mips:Linux:*:* | mips64:Linux:*:*)
eval $set_cc_for_build
sed 's/^ //' << EOF >$dummy.c
#undef CPU
#undef ${UNAME_MACHINE}
#undef ${UNAME_MACHINE}el
#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
CPU=${UNAME_MACHINE}el
#else
#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
CPU=${UNAME_MACHINE}
#else
CPU=
#endif
#endif
EOF
eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; }
;;
or1k:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
or32:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
padre:Linux:*:*)
echo sparc-unknown-linux-${LIBC}
exit ;;
parisc64:Linux:*:* | hppa64:Linux:*:*)
echo hppa64-unknown-linux-${LIBC}
exit ;;
parisc:Linux:*:* | hppa:Linux:*:*)
# Look for CPU level
case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
PA7*) echo hppa1.1-unknown-linux-${LIBC} ;;
PA8*) echo hppa2.0-unknown-linux-${LIBC} ;;
*) echo hppa-unknown-linux-${LIBC} ;;
esac
exit ;;
ppc64:Linux:*:*)
echo powerpc64-unknown-linux-${LIBC}
exit ;;
ppc:Linux:*:*)
echo powerpc-unknown-linux-${LIBC}
exit ;;
ppc64le:Linux:*:*)
echo powerpc64le-unknown-linux-${LIBC}
exit ;;
ppcle:Linux:*:*)
echo powerpcle-unknown-linux-${LIBC}
exit ;;
s390:Linux:*:* | s390x:Linux:*:*)
echo ${UNAME_MACHINE}-ibm-linux-${LIBC}
exit ;;
sh64*:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
sh*:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
sparc:Linux:*:* | sparc64:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
tile*:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
vax:Linux:*:*)
echo ${UNAME_MACHINE}-dec-linux-${LIBC}
exit ;;
x86_64:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
xtensa*:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
i*86:DYNIX/ptx:4*:*)
# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
# earlier versions are messed up and put the nodename in both
# sysname and nodename.
echo i386-sequent-sysv4
exit ;;
i*86:UNIX_SV:4.2MP:2.*)
# Unixware is an offshoot of SVR4, but it has its own version
# number series starting with 2...
# I am not positive that other SVR4 systems won't match this,
# I just have to hope. -- rms.
# Use sysv4.2uw... so that sysv4* matches it.
echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
exit ;;
i*86:OS/2:*:*)
# If we were able to find `uname', then EMX Unix compatibility
# is probably installed.
echo ${UNAME_MACHINE}-pc-os2-emx
exit ;;
i*86:XTS-300:*:STOP)
echo ${UNAME_MACHINE}-unknown-stop
exit ;;
i*86:atheos:*:*)
echo ${UNAME_MACHINE}-unknown-atheos
exit ;;
i*86:syllable:*:*)
echo ${UNAME_MACHINE}-pc-syllable
exit ;;
i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
echo i386-unknown-lynxos${UNAME_RELEASE}
exit ;;
i*86:*DOS:*:*)
echo ${UNAME_MACHINE}-pc-msdosdjgpp
exit ;;
i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
else
echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
fi
exit ;;
i*86:*:5:[678]*)
# UnixWare 7.x, OpenUNIX and OpenServer 6.
case `/bin/uname -X | grep "^Machine"` in
*486*) UNAME_MACHINE=i486 ;;
*Pentium) UNAME_MACHINE=i586 ;;
*Pent*|*Celeron) UNAME_MACHINE=i686 ;;
esac
echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
exit ;;
i*86:*:3.2:*)
if test -f /usr/options/cb.name; then
UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
elif /bin/uname -X 2>/dev/null >/dev/null ; then
UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
&& UNAME_MACHINE=i586
(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
&& UNAME_MACHINE=i686
(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
&& UNAME_MACHINE=i686
echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
else
echo ${UNAME_MACHINE}-pc-sysv32
fi
exit ;;
pc:*:*:*)
# Left here for compatibility:
# uname -m prints for DJGPP always 'pc', but it prints nothing about
# the processor, so we play safe by assuming i586.
# Note: whatever this is, it MUST be the same as what config.sub
# prints for the "djgpp" host, or else GDB configury will decide that
# this is a cross-build.
echo i586-pc-msdosdjgpp
exit ;;
Intel:Mach:3*:*)
echo i386-pc-mach3
exit ;;
paragon:*:*:*)
echo i860-intel-osf1
exit ;;
i860:*:4.*:*) # i860-SVR4
if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
else # Add other i860-SVR4 vendors below as they are discovered.
echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4
fi
exit ;;
mini*:CTIX:SYS*5:*)
# "miniframe"
echo m68010-convergent-sysv
exit ;;
mc68k:UNIX:SYSTEM5:3.51m)
echo m68k-convergent-sysv
exit ;;
M680?0:D-NIX:5.3:*)
echo m68k-diab-dnix
exit ;;
M68*:*:R3V[5678]*:*)
test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
OS_REL=''
test -r /etc/.relid \
&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
&& { echo i486-ncr-sysv4.3${OS_REL}; exit; }
/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
&& { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
&& { echo i486-ncr-sysv4; exit; } ;;
NCR*:*:4.2:* | MPRAS*:*:4.2:*)
OS_REL='.3'
test -r /etc/.relid \
&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
&& { echo i486-ncr-sysv4.3${OS_REL}; exit; }
/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
&& { echo i586-ncr-sysv4.3${OS_REL}; exit; }
/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
&& { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
echo m68k-unknown-lynxos${UNAME_RELEASE}
exit ;;
mc68030:UNIX_System_V:4.*:*)
echo m68k-atari-sysv4
exit ;;
TSUNAMI:LynxOS:2.*:*)
echo sparc-unknown-lynxos${UNAME_RELEASE}
exit ;;
rs6000:LynxOS:2.*:*)
echo rs6000-unknown-lynxos${UNAME_RELEASE}
exit ;;
PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
echo powerpc-unknown-lynxos${UNAME_RELEASE}
exit ;;
SM[BE]S:UNIX_SV:*:*)
echo mips-dde-sysv${UNAME_RELEASE}
exit ;;
RM*:ReliantUNIX-*:*:*)
echo mips-sni-sysv4
exit ;;
RM*:SINIX-*:*:*)
echo mips-sni-sysv4
exit ;;
*:SINIX-*:*:*)
if uname -p 2>/dev/null >/dev/null ; then
UNAME_MACHINE=`(uname -p) 2>/dev/null`
echo ${UNAME_MACHINE}-sni-sysv4
else
echo ns32k-sni-sysv
fi
exit ;;
PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
# says <Richard.M.Bartel@ccMail.Census.GOV>
echo i586-unisys-sysv4
exit ;;
*:UNIX_System_V:4*:FTX*)
# From Gerald Hewes <hewes@openmarket.com>.
# How about differentiating between stratus architectures? -djm
echo hppa1.1-stratus-sysv4
exit ;;
*:*:*:FTX*)
# From seanf@swdc.stratus.com.
echo i860-stratus-sysv4
exit ;;
i*86:VOS:*:*)
# From Paul.Green@stratus.com.
echo ${UNAME_MACHINE}-stratus-vos
exit ;;
*:VOS:*:*)
# From Paul.Green@stratus.com.
echo hppa1.1-stratus-vos
exit ;;
mc68*:A/UX:*:*)
echo m68k-apple-aux${UNAME_RELEASE}
exit ;;
news*:NEWS-OS:6*:*)
echo mips-sony-newsos6
exit ;;
R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
if [ -d /usr/nec ]; then
echo mips-nec-sysv${UNAME_RELEASE}
else
echo mips-unknown-sysv${UNAME_RELEASE}
fi
exit ;;
BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only.
echo powerpc-be-beos
exit ;;
BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only.
echo powerpc-apple-beos
exit ;;
BePC:BeOS:*:*) # BeOS running on Intel PC compatible.
echo i586-pc-beos
exit ;;
BePC:Haiku:*:*) # Haiku running on Intel PC compatible.
echo i586-pc-haiku
exit ;;
x86_64:Haiku:*:*)
echo x86_64-unknown-haiku
exit ;;
SX-4:SUPER-UX:*:*)
echo sx4-nec-superux${UNAME_RELEASE}
exit ;;
SX-5:SUPER-UX:*:*)
echo sx5-nec-superux${UNAME_RELEASE}
exit ;;
SX-6:SUPER-UX:*:*)
echo sx6-nec-superux${UNAME_RELEASE}
exit ;;
SX-7:SUPER-UX:*:*)
echo sx7-nec-superux${UNAME_RELEASE}
exit ;;
SX-8:SUPER-UX:*:*)
echo sx8-nec-superux${UNAME_RELEASE}
exit ;;
SX-8R:SUPER-UX:*:*)
echo sx8r-nec-superux${UNAME_RELEASE}
exit ;;
Power*:Rhapsody:*:*)
echo powerpc-apple-rhapsody${UNAME_RELEASE}
exit ;;
*:Rhapsody:*:*)
echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
exit ;;
*:Darwin:*:*)
UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
eval $set_cc_for_build
if test "$UNAME_PROCESSOR" = unknown ; then
UNAME_PROCESSOR=powerpc
fi
if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
grep IS_64BIT_ARCH >/dev/null
then
case $UNAME_PROCESSOR in
i386) UNAME_PROCESSOR=x86_64 ;;
powerpc) UNAME_PROCESSOR=powerpc64 ;;
esac
fi
fi
echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
exit ;;
*:procnto*:*:* | *:QNX:[0123456789]*:*)
UNAME_PROCESSOR=`uname -p`
if test "$UNAME_PROCESSOR" = "x86"; then
UNAME_PROCESSOR=i386
UNAME_MACHINE=pc
fi
echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
exit ;;
*:QNX:*:4*)
echo i386-pc-qnx
exit ;;
NEO-?:NONSTOP_KERNEL:*:*)
echo neo-tandem-nsk${UNAME_RELEASE}
exit ;;
NSE-*:NONSTOP_KERNEL:*:*)
echo nse-tandem-nsk${UNAME_RELEASE}
exit ;;
NSR-?:NONSTOP_KERNEL:*:*)
echo nsr-tandem-nsk${UNAME_RELEASE}
exit ;;
*:NonStop-UX:*:*)
echo mips-compaq-nonstopux
exit ;;
BS2000:POSIX*:*:*)
echo bs2000-siemens-sysv
exit ;;
DS/*:UNIX_System_V:*:*)
echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
exit ;;
*:Plan9:*:*)
# "uname -m" is not consistent, so use $cputype instead. 386
# is converted to i386 for consistency with other x86
# operating systems.
if test "$cputype" = "386"; then
UNAME_MACHINE=i386
else
UNAME_MACHINE="$cputype"
fi
echo ${UNAME_MACHINE}-unknown-plan9
exit ;;
*:TOPS-10:*:*)
echo pdp10-unknown-tops10
exit ;;
*:TENEX:*:*)
echo pdp10-unknown-tenex
exit ;;
KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
echo pdp10-dec-tops20
exit ;;
XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
echo pdp10-xkl-tops20
exit ;;
*:TOPS-20:*:*)
echo pdp10-unknown-tops20
exit ;;
*:ITS:*:*)
echo pdp10-unknown-its
exit ;;
SEI:*:*:SEIUX)
echo mips-sei-seiux${UNAME_RELEASE}
exit ;;
*:DragonFly:*:*)
echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
exit ;;
*:*VMS:*:*)
UNAME_MACHINE=`(uname -p) 2>/dev/null`
case "${UNAME_MACHINE}" in
A*) echo alpha-dec-vms ; exit ;;
I*) echo ia64-dec-vms ; exit ;;
V*) echo vax-dec-vms ; exit ;;
esac ;;
*:XENIX:*:SysV)
echo i386-pc-xenix
exit ;;
i*86:skyos:*:*)
echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//'
exit ;;
i*86:rdos:*:*)
echo ${UNAME_MACHINE}-pc-rdos
exit ;;
i*86:AROS:*:*)
echo ${UNAME_MACHINE}-pc-aros
exit ;;
x86_64:VMkernel:*:*)
echo ${UNAME_MACHINE}-unknown-esx
exit ;;
esac
eval $set_cc_for_build
cat >$dummy.c <<EOF
#ifdef _SEQUENT_
# include <sys/types.h>
# include <sys/utsname.h>
#endif
main ()
{
#if defined (sony)
#if defined (MIPSEB)
/* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed,
I don't know.... */
printf ("mips-sony-bsd\n"); exit (0);
#else
#include <sys/param.h>
printf ("m68k-sony-newsos%s\n",
#ifdef NEWSOS4
"4"
#else
""
#endif
); exit (0);
#endif
#endif
#if defined (__arm) && defined (__acorn) && defined (__unix)
printf ("arm-acorn-riscix\n"); exit (0);
#endif
#if defined (hp300) && !defined (hpux)
printf ("m68k-hp-bsd\n"); exit (0);
#endif
#if defined (NeXT)
#if !defined (__ARCHITECTURE__)
#define __ARCHITECTURE__ "m68k"
#endif
int version;
version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
if (version < 4)
printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
else
printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
exit (0);
#endif
#if defined (MULTIMAX) || defined (n16)
#if defined (UMAXV)
printf ("ns32k-encore-sysv\n"); exit (0);
#else
#if defined (CMU)
printf ("ns32k-encore-mach\n"); exit (0);
#else
printf ("ns32k-encore-bsd\n"); exit (0);
#endif
#endif
#endif
#if defined (__386BSD__)
printf ("i386-pc-bsd\n"); exit (0);
#endif
#if defined (sequent)
#if defined (i386)
printf ("i386-sequent-dynix\n"); exit (0);
#endif
#if defined (ns32000)
printf ("ns32k-sequent-dynix\n"); exit (0);
#endif
#endif
#if defined (_SEQUENT_)
struct utsname un;
uname(&un);
if (strncmp(un.version, "V2", 2) == 0) {
printf ("i386-sequent-ptx2\n"); exit (0);
}
if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
printf ("i386-sequent-ptx1\n"); exit (0);
}
printf ("i386-sequent-ptx\n"); exit (0);
#endif
#if defined (vax)
# if !defined (ultrix)
# include <sys/param.h>
# if defined (BSD)
# if BSD == 43
printf ("vax-dec-bsd4.3\n"); exit (0);
# else
# if BSD == 199006
printf ("vax-dec-bsd4.3reno\n"); exit (0);
# else
printf ("vax-dec-bsd\n"); exit (0);
# endif
# endif
# else
printf ("vax-dec-bsd\n"); exit (0);
# endif
# else
printf ("vax-dec-ultrix\n"); exit (0);
# endif
#endif
#if defined (alliant) && defined (i860)
printf ("i860-alliant-bsd\n"); exit (0);
#endif
exit (1);
}
EOF
$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` &&
{ echo "$SYSTEM_NAME"; exit; }
# Apollos put the system type in the environment.
test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; }
# Convex versions that predate uname can use getsysinfo(1)
if [ -x /usr/convex/getsysinfo ]
then
case `getsysinfo -f cpu_type` in
c1*)
echo c1-convex-bsd
exit ;;
c2*)
if getsysinfo -f scalar_acc
then echo c32-convex-bsd
else echo c2-convex-bsd
fi
exit ;;
c34*)
echo c34-convex-bsd
exit ;;
c38*)
echo c38-convex-bsd
exit ;;
c4*)
echo c4-convex-bsd
exit ;;
esac
fi
cat >&2 <<EOF
$0: unable to guess system type
This script, last modified $timestamp, has failed to recognize
the operating system you are using. It is advised that you
download the most up to date version of the config scripts from
http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
and
http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
If the version you run ($0) is already up to date, please
send the following data and any information you think might be
pertinent to <config-patches@gnu.org> in order to provide the needed
information to handle your system.
config.guess timestamp = $timestamp
uname -m = `(uname -m) 2>/dev/null || echo unknown`
uname -r = `(uname -r) 2>/dev/null || echo unknown`
uname -s = `(uname -s) 2>/dev/null || echo unknown`
uname -v = `(uname -v) 2>/dev/null || echo unknown`
/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
/bin/uname -X = `(/bin/uname -X) 2>/dev/null`
hostinfo = `(hostinfo) 2>/dev/null`
/bin/universe = `(/bin/universe) 2>/dev/null`
/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null`
/bin/arch = `(/bin/arch) 2>/dev/null`
/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null`
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
UNAME_MACHINE = ${UNAME_MACHINE}
UNAME_RELEASE = ${UNAME_RELEASE}
UNAME_SYSTEM = ${UNAME_SYSTEM}
UNAME_VERSION = ${UNAME_VERSION}
EOF
exit 1
# Local variables:
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "timestamp='"
# time-stamp-format: "%:y-%02m-%02d"
# time-stamp-end: "'"
# End:
|
281677160/openwrt-package | 1,350 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/test/default/box8.c |
#define TEST_NAME "box8"
#include "cmptest.h"
unsigned char alicesk[crypto_box_SECRETKEYBYTES];
unsigned char alicepk[crypto_box_PUBLICKEYBYTES];
unsigned char bobsk[crypto_box_SECRETKEYBYTES];
unsigned char bobpk[crypto_box_PUBLICKEYBYTES];
unsigned char n[crypto_box_NONCEBYTES];
unsigned char m[10000];
unsigned char c[10000];
unsigned char m2[10000];
int main(void)
{
size_t mlen;
size_t i;
int caught;
for (mlen = 0; mlen < 1000 && mlen + crypto_box_ZEROBYTES < sizeof m;
++mlen) {
crypto_box_keypair(alicepk, alicesk);
crypto_box_keypair(bobpk, bobsk);
randombytes_buf(n, crypto_box_NONCEBYTES);
randombytes_buf(m + crypto_box_ZEROBYTES, mlen);
crypto_box(c, m, mlen + crypto_box_ZEROBYTES, n, bobpk, alicesk);
caught = 0;
while (caught < 10) {
c[rand() % (mlen + crypto_box_ZEROBYTES)] = rand();
if (crypto_box_open(m2, c, mlen + crypto_box_ZEROBYTES, n, alicepk,
bobsk) == 0) {
for (i = 0; i < mlen + crypto_box_ZEROBYTES; ++i) {
if (m2[i] != m[i]) {
printf("forgery\n");
return 100;
}
}
} else {
++caught;
}
}
}
return 0;
}
|
281677160/openwrt-package | 3,085 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/test/default/randombytes.c |
#define TEST_NAME "randombytes"
#include "cmptest.h"
unsigned char x[65536];
unsigned long long freq[256];
static int compat_tests(void)
{
size_t i;
memset(x, 0, sizeof x);
randombytes(x, sizeof x);
for (i = 0; i < 256; ++i) {
freq[i] = 0;
}
for (i = 0; i < sizeof x; ++i) {
++freq[255 & (int)x[i]];
}
for (i = 0; i < 256; ++i) {
if (!freq[i]) {
printf("nacl_tests failed\n");
}
}
return 0;
}
static int randombytes_tests(void)
{
unsigned int f = 0U;
unsigned int i;
uint32_t n;
#ifdef __EMSCRIPTEN__
assert(strcmp(randombytes_implementation_name(), "sysrandom"));
#else
assert(strcmp(randombytes_implementation_name(), "js"));
#endif
randombytes(x, 1U);
do {
n = randombytes_random();
f |= ((n >> 24) > 1);
f |= ((n >> 16) > 1) << 1;
f |= ((n >> 8) > 1) << 2;
f |= ((n ) > 1) << 3;
f |= (n > 0x7fffffff) << 4;
} while (f != 0x1f);
randombytes_close();
for (i = 0; i < 256; ++i) {
freq[i] = 0;
}
for (i = 0; i < 65536; ++i) {
++freq[randombytes_uniform(256)];
}
for (i = 0; i < 256; ++i) {
if (!freq[i]) {
printf("randombytes_uniform() test failed\n");
}
}
assert(randombytes_uniform(1U) == 0U);
randombytes_close();
#ifndef __EMSCRIPTEN__
randombytes_set_implementation(&randombytes_salsa20_implementation);
assert(strcmp(randombytes_implementation_name(), "salsa20") == 0);
#endif
randombytes_stir();
for (i = 0; i < 256; ++i) {
freq[i] = 0;
}
for (i = 0; i < 65536; ++i) {
++freq[randombytes_uniform(256)];
}
for (i = 0; i < 256; ++i) {
if (!freq[i]) {
printf("randombytes_uniform() test failed\n");
}
}
memset(x, 0, sizeof x);
randombytes_buf(x, sizeof x);
for (i = 0; i < 256; ++i) {
freq[i] = 0;
}
for (i = 0; i < sizeof x; ++i) {
++freq[255 & (int)x[i]];
}
for (i = 0; i < 256; ++i) {
if (!freq[i]) {
printf("randombytes_buf() test failed\n");
}
}
assert(randombytes_uniform(1U) == 0U);
randombytes_close();
randombytes(x, 1U);
randombytes_close();
return 0;
}
static uint32_t randombytes_uniform_impl(const uint32_t upper_bound)
{
return upper_bound;
}
static int impl_tests(void)
{
randombytes_implementation impl = randombytes_sysrandom_implementation;
uint32_t v = randombytes_random();
impl.uniform = randombytes_uniform_impl;
randombytes_close();
randombytes_set_implementation(&impl);
assert(randombytes_uniform(v) == v);
assert(randombytes_uniform(v) == v);
assert(randombytes_uniform(v) == v);
assert(randombytes_uniform(v) == v);
randombytes_close();
impl.close = NULL;
randombytes_close();
return 0;
}
int main(void)
{
compat_tests();
randombytes_tests();
#ifndef __EMSCRIPTEN__
impl_tests();
#endif
printf("OK\n");
return 0;
}
|
281677160/openwrt-package | 16,511 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/test/default/pwhash.c |
#define TEST_NAME "pwhash"
#include "cmptest.h"
#define OUT_LEN 128
#define OPSLIMIT 1000000
#define MEMLIMIT 10000000
static void tv(void)
{
static struct {
const char *passwd_hex;
size_t passwdlen;
const char *salt_hex;
size_t outlen;
unsigned long long opslimit;
size_t memlimit;
} tests[] = {
{ "a347ae92bce9f80f6f595a4480fc9c2fe7e7d7148d371e9487d75f5c23008ffae0"
"65577a928febd9b1973a5a95073acdbeb6a030cfc0d79caa2dc5cd011cef02c08d"
"a232d76d52dfbca38ca8dcbd665b17d1665f7cf5fe59772ec909733b24de97d6f5"
"8d220b20c60d7c07ec1fd93c52c31020300c6c1facd77937a597c7a6",
127,
"5541fbc995d5c197ba290346d2c559dedf405cf97e5f95482143202f9e74f5c2",
155, 481326, 7256678 },
{ "e125cee61c8cb7778d9e5ad0a6f5d978ce9f84de213a8556d9ffe202020ab4a6ed"
"9074a4eb3416f9b168f137510f3a30b70b96cbfa219ff99f6c6eaffb15c06b60e0"
"0cc2890277f0fd3c622115772f7048adaebed86e",
86,
"f1192dd5dc2368b9cd421338b22433455ee0a3699f9379a08b9650ea2c126f0d",
250, 535778, 7849083 },
{ "92263cbf6ac376499f68a4289d3bb59e5a22335eba63a32e6410249155b956b6a3"
"b48d4a44906b18b897127300b375b8f834f1ceffc70880a885f47c33876717e392"
"be57f7da3ae58da4fd1f43daa7e44bb82d3717af4319349c24cd31e46d295856b0"
"441b6b289992a11ced1cc3bf3011604590244a3eb737ff221129215e4e4347f491"
"5d41292b5173d196eb9add693be5319fdadc242906178bb6c0286c9b6ca6012746"
"711f58c8c392016b2fdfc09c64f0f6b6ab7b",
183,
"3b840e20e9555e9fb031c4ba1f1747ce25cc1d0ff664be676b9b4a90641ff194",
249, 311757, 7994791 },
{ "027b6d8e8c8c474e9b69c7d9ed4f9971e8e1ce2f6ba95048414c3970f0f09b70e3"
"b6c5ae05872b3d8678705b7d381829c351a5a9c88c233569b35d6b0b809df44b64"
"51a9c273f1150e2ef8a0b5437eb701e373474cd44b97ef0248ebce2ca0400e1b53"
"f3d86221eca3f18eb45b702b9172440f774a82cbf1f6f525df30a6e293c873cce6"
"9bb078ed1f0d31e7f9b8062409f37f19f8550aae",
152,
"eb2a3056a09ad2d7d7f975bcd707598f24cd32518cde3069f2e403b34bfee8a5",
5, 643464, 1397645 },
{ "4a857e2ee8aa9b6056f2424e84d24a72473378906ee04a46cb05311502d5250b82"
"ad86b83c8f20a23dbb74f6da60b0b6ecffd67134d45946ac8ebfb3064294bc097d"
"43ced68642bfb8bbbdd0f50b30118f5e",
82,
"39d82eef32010b8b79cc5ba88ed539fbaba741100f2edbeca7cc171ffeabf258",
190, 758010, 5432947 },
{ "1845e375479537e9dd4f4486d5c91ac72775d66605eeb11a787b78a7745f1fd005"
"2d526c67235dbae1b2a4d575a74cb551c8e9096c593a497aee74ba3047d911358e"
"de57bc27c9ea1829824348daaab606217cc931dcb6627787bd6e4e5854f0e8",
97,
"3ee91a805aa62cfbe8dce29a2d9a44373a5006f4a4ce24022aca9cecb29d1473",
212, 233177, 13101817 },
{ "c7b09aec680e7b42fedd7fc792e78b2f6c1bea8f4a884320b648f81e8cf515e8ba"
"9dcfb11d43c4aae114c1734aa69ca82d44998365db9c93744fa28b63fd16000e82"
"61cbbe083e7e2da1e5f696bde0834fe53146d7e0e35e7de9920d041f5a5621aabe"
"02da3e2b09b405b77937efef3197bd5772e41fdb73fb5294478e45208063b5f58e"
"089dbeb6d6342a909c1307b3fff5fe2cf4da56bdae50848f",
156,
"039c056d933b475032777edbaffac50f143f64c123329ed9cf59e3b65d3f43b6",
178, 234753, 4886999 },
{ "8f3a06e2fd8711350a517bb12e31f3d3423e8dc0bb14aac8240fca0995938d59bb"
"37bd0a7dfc9c9cc0705684b46612e8c8b1d6655fb0f9887562bb9899791a0250d1"
"320f945eda48cdc20c233f40a5bb0a7e3ac5ad7250ce684f68fc0b8c9633bfd75a"
"ad116525af7bdcdbbdb4e00ab163fd4df08f243f12557e",
122,
"90631f686a8c3dbc0703ffa353bc1fdf35774568ac62406f98a13ed8f47595fd",
55, 695191, 15738350 },
{ "b540beb016a5366524d4605156493f9874514a5aa58818cd0c6dfffaa9e90205f1"
"7b",
34,
"44071f6d181561670bda728d43fb79b443bb805afdebaf98622b5165e01b15fb",
231, 78652, 6631659 },
{ "a14975c26c088755a8b715ff2528d647cd343987fcf4aa25e7194a8417fb2b4b3f"
"7268da9f3182b4cfb22d138b2749d673a47ecc7525dd15a0a3c66046971784bb63"
"d7eae24cc84f2631712075a10e10a96b0e0ee67c43e01c423cb9c44e5371017e9c"
"496956b632158da3fe12addecb88912e6759bc37f9af2f45af72c5cae3b179ffb6"
"76a697de6ebe45cd4c16d4a9d642d29ddc0186a0a48cb6cd62bfc3dd229d313b30"
"1560971e740e2cf1f99a9a090a5b283f35475057e96d7064e2e0fc81984591068d"
"55a3b4169f22cccb0745a2689407ea1901a0a766eb99",
220,
"3d968b2752b8838431165059319f3ff8910b7b8ecb54ea01d3f54769e9d98daf",
167, 717248, 10784179 },
};
char passwd[256];
unsigned char salt[crypto_pwhash_scryptsalsa208sha256_SALTBYTES];
unsigned char out[256];
char out_hex[256 * 2 + 1];
size_t i = 0U;
do {
sodium_hex2bin((unsigned char *) passwd, sizeof passwd,
tests[i].passwd_hex, strlen(tests[i].passwd_hex), NULL,
NULL, NULL);
sodium_hex2bin(salt, sizeof salt, tests[i].salt_hex,
strlen(tests[i].salt_hex), NULL, NULL, NULL);
if (crypto_pwhash_scryptsalsa208sha256(
out, (unsigned long long) tests[i].outlen,
passwd, tests[i].passwdlen,
(const unsigned char *) salt, tests[i].opslimit,
tests[i].memlimit) != 0) {
printf("pwhash failure\n");
}
sodium_bin2hex(out_hex, sizeof out_hex, out, tests[i].outlen);
printf("%s\n", out_hex);
} while (++i < (sizeof tests) / (sizeof tests[0]));
}
static void tv2(void)
{
static struct {
const char *passwd_hex;
size_t passwdlen;
const char *salt_hex;
size_t outlen;
unsigned long long opslimit;
size_t memlimit;
} tests[] = {
{ "a347ae92bce9f80f6f595a4480fc9c2fe7e7d7148d371e9487d75f5c23008ffae0"
"65577a928febd9b1973a5a95073acdbeb6a030cfc0d79caa2dc5cd011cef02c08d"
"a232d76d52dfbca38ca8dcbd665b17d1665f7cf5fe59772ec909733b24de97d6f5"
"8d220b20c60d7c07ec1fd93c52c31020300c6c1facd77937a597c7a6",
127,
"5541fbc995d5c197ba290346d2c559dedf405cf97e5f95482143202f9e74f5c2",
155, 64, 1397645 },
{ "a347ae92bce9f80f6f595a4480fc9c2fe7e7d7148d371e9487d75f5c23008ffae0"
"65577a928febd9b1973a5a95073acdbeb6a030cfc0d79caa2dc5cd011cef02c08d"
"a232d76d52dfbca38ca8dcbd665b17d1665f7cf5fe59772ec909733b24de97d6f5"
"8d220b20c60d7c07ec1fd93c52c31020300c6c1facd77937a597c7a6",
127,
"5541fbc995d5c197ba290346d2c559dedf405cf97e5f95482143202f9e74f5c2",
155, 32768, 1397645 },
};
char passwd[256];
unsigned char salt[crypto_pwhash_scryptsalsa208sha256_SALTBYTES];
unsigned char out[256];
char out_hex[256 * 2 + 1];
size_t i = 0U;
do {
sodium_hex2bin((unsigned char *)passwd, sizeof passwd,
tests[i].passwd_hex, strlen(tests[i].passwd_hex), NULL,
NULL, NULL);
sodium_hex2bin(salt, sizeof salt, tests[i].salt_hex,
strlen(tests[i].salt_hex), NULL, NULL, NULL);
if (crypto_pwhash_scryptsalsa208sha256(
out, (unsigned long long) tests[i].outlen,
passwd, tests[i].passwdlen,
(const unsigned char *) salt, tests[i].opslimit,
tests[i].memlimit) != 0) {
printf("pwhash failure\n");
}
sodium_bin2hex(out_hex, sizeof out_hex, out, tests[i].outlen);
printf("%s\n", out_hex);
} while (++i < (sizeof tests) / (sizeof tests[0]));
}
static void tv3(void)
{
static struct {
const char *passwd;
const char *out;
} tests[] = {
{ "^T5H$JYt39n%K*j:W]!1s?vg!:jGi]Ax?..l7[p0v:1jHTpla9;]bUN;?bWyCbtqg "
"nrDFal+Jxl3,2`#^tFSu%v_+7iYse8-cCkNf!tD=KrW)",
"$7$B6....1....75gBMAGwfFWZqBdyF3WdTQnWdUsuTiWjG1fF9c1jiSD$tc8RoB3."
"Em3/zNgMLWo2u00oGIoTyJv4fl3Fl8Tix72" },
{ "bl72h6#y<':MFRZ>B IA1=NRkCKS%W8`1I.2uQxJN0g)N N aTt^4K!Iw5r "
"H6;crDsv^a55j9tsk'/GqweZn;cdk6+F_St6:#*=?ZCD_lw>.",
"$7$A6....3....Iahc6qM0.UQJHVgE4h9oa1/"
"4OWlWLm9CCtfguvz6bQD$QnXCo3M7nIqtry2WKsUZ5gQ.mY0wAlJu."
"WUhtE8vF66" },
{ "Py "
">e.5b+tLo@rL`dC2k@eJ&4eVl!W=JJ4+k&mAt@gt',FS1JjqKW3aq21:]^kna`"
"mde7kVkN5NrpKUptu)@4*b&?BE_sJMG1=&@`3GBCV]Wg7xwgo7x3El",
"$7$96..../....f6bEusKt79kK4wdYN0ki2nw4bJQ7P3rN6k3BSigsK/"
"D$Dsvuw7vXj5xijmrb/NOhdgoyK/OiSIYv88cEtl9Cik7" },
{ "2vj;Um]FKOL27oam(:Uo8+UmSTvb1FD*h?jk_,S=;RDgF-$Fjk?]9yvfxe@fN^!NN("
"Cuml?+2Raa",
"$7$86....I....7XwIxLtCx4VphmFeUa6OGuGJrFaIaYzDiLNu/"
"tyUPhD$U3q5GCEqCWxMwh.YQHDJrlg7FIZgViv9pcXE3h1vg61" },
{ "CT=[9uUoGav,J`kU+348tA50ue#sL:ABZ3QgF+r[#vh:tTOiL>s8tv%,Jeo]jH/"
"_4^i(*jD-_ku[9Ko[=86 06V",
"$7$A6....2....R3.bjH6YS9wz9z8Jsj.3weGQ3J80ZZElGw2oVux1TP6$"
"i5u6lFzXDHaIgYEICinLD6WNaovbiXP8SnLrDRdKgA9" },
{ "J#wNn`hDgOpTHNI.w^1a70%f,.9V_m038H_JIJQln`vdWnn/"
"rmILR?9H5g(+`;@H(2VosN9Fgk[WEjaBr'yB9Q19-imNa04[Mk5kvGcSn-TV",
"$7$B6....1....Dj1y.4mF1J9XmT/6IDskYdCLaPFJTq9xcCwXQ1DpT92$92/"
"hYfZLRq1nTLyIz.uc/dC6wLqwnsoqpkadrCXusm6" },
{ "j4BS38Asa;p)[K+9TY!3YDj<LK-`nLVXQw9%*QfM",
"$7$B6....1....5Ods8mojVwXJq4AywF/uI9BdMSiJ/zT8hQP/"
"4cB68VC$nk4ExHNXJ802froj51/1wJTrSZvTIyyK7PecOxRRaz0" },
{ "M.R>Qw+!qJb]>pP :_.9`dxM9k [eR7Y!yL-3)sNs[R,j_/^ "
"TH=5ny'15>6UXWcQW^6D%XCsO[vN[%ReA-`tV1vW(Nt*0KVK#]45P_A",
"$7$B6....1....D/"
"eyk8N5y6Z8YVQEsw521cTx.9zzLuK7YDs1KMMh.o4$alfW8ZbsUWnXc."
"vqon2zoljVk24Tt1.IsCuo2KurvS2" },
{ "K3S=KyH#)36_?]LxeR8QNKw6X=gFb'ai$C%29V* "
"tyh^Wo$TN-#Q4qkmtTCf0LLb.^E$0uykkP",
"$7$B6....1....CuBuU97xgAage8whp/"
"JNKobo0TFbsORGVbfcQIefyP8$aqalP."
"XofGViB8EPLONqHma8vs1xc9uTIMYh9CgE.S8" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$A6....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5" },
/* Invalid pwhash strings */
{ "Y0!?iQa9M%5ekffW(`",
"$7$A6....1....$TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$.6....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$A.....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$A6.........TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$A6....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i44269$"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AH" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$A6....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx54269" },
{ "Y0!?iQa9M%5ekffW(`",
"$7^A6....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$!6....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$A!....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$A6....!....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5" },
{ "",
"$7$A6....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5" },
{ "Y0!?iQa9M%5ekffW(`",
"$7fA6....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4#"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$AX....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$A6....1!...TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$A6....1" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$" },
{ "Y0!?iQa9M%5ekffW(`",
"" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$A6....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$"
"" },
};
char *out;
char *passwd;
size_t i = 0U;
do {
out = (char *) sodium_malloc(strlen(tests[i].out) + 1U);
assert(out != NULL);
memcpy(out, tests[i].out, strlen(tests[i].out) + 1U);
passwd = (char *) sodium_malloc(strlen(tests[i].passwd) + 1U);
assert(passwd != NULL);
memcpy(passwd, tests[i].passwd, strlen(tests[i].passwd) + 1U);
if (crypto_pwhash_scryptsalsa208sha256_str_verify
(out, passwd, strlen(passwd)) != 0) {
printf("pwhash_str failure: [%u]\n", (unsigned int)i);
}
sodium_free(out);
sodium_free(passwd);
} while (++i < (sizeof tests) / (sizeof tests[0]));
}
int main(void)
{
char *str_out;
char *str_out2;
char *salt;
const char *passwd = "Correct Horse Battery Staple";
tv();
tv2();
tv3();
salt = (char *)
sodium_malloc(crypto_pwhash_scryptsalsa208sha256_SALTBYTES);
str_out = (char *)
sodium_malloc(crypto_pwhash_scryptsalsa208sha256_STRBYTES);
str_out2 = (char *)
sodium_malloc(crypto_pwhash_scryptsalsa208sha256_STRBYTES);
memcpy(salt, "[<~A 32-bytes salt for scrypt~>]",
crypto_pwhash_scryptsalsa208sha256_SALTBYTES);
if (crypto_pwhash_scryptsalsa208sha256_str(str_out, passwd, strlen(passwd),
OPSLIMIT, MEMLIMIT) != 0) {
printf("pwhash_str failure\n");
}
if (crypto_pwhash_scryptsalsa208sha256_str(str_out2, passwd, strlen(passwd),
OPSLIMIT, MEMLIMIT) != 0) {
printf("pwhash_str(2) failure\n");
}
if (strcmp(str_out, str_out2) == 0) {
printf("pwhash_str doesn't generate different salts\n");
}
if (crypto_pwhash_scryptsalsa208sha256_str_verify(str_out, passwd,
strlen(passwd)) != 0) {
printf("pwhash_str_verify failure\n");
}
if (crypto_pwhash_scryptsalsa208sha256_str_verify(str_out, passwd,
strlen(passwd)) != 0) {
printf("pwhash_str_verify failure\n");
}
str_out[14]++;
if (crypto_pwhash_scryptsalsa208sha256_str_verify(
str_out, passwd, strlen(passwd)) == 0) {
printf("pwhash_str_verify(2) failure\n");
}
str_out[14]--;
assert(str_out[crypto_pwhash_scryptsalsa208sha256_STRBYTES - 1U] == 0);
assert(crypto_pwhash_scryptsalsa208sha256_saltbytes() > 0U);
assert(crypto_pwhash_scryptsalsa208sha256_strbytes() > 1U);
assert(crypto_pwhash_scryptsalsa208sha256_strbytes() >
strlen(crypto_pwhash_scryptsalsa208sha256_strprefix()));
assert(crypto_pwhash_scryptsalsa208sha256_opslimit_interactive() > 0U);
assert(crypto_pwhash_scryptsalsa208sha256_memlimit_interactive() > 0U);
assert(crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive() > 0U);
assert(crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive() > 0U);
sodium_free(salt);
sodium_free(str_out);
sodium_free(str_out2);
printf("OK\n");
return 0;
}
|
281677160/openwrt-package | 2,287 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/test/default/sodium_utils.c |
#define TEST_NAME "sodium_utils"
#include "cmptest.h"
int main(void)
{
unsigned char buf1[1000];
unsigned char buf2[1000];
char buf3[33];
unsigned char buf4[4];
const char *hex;
const char *hex_end;
size_t bin_len;
randombytes_buf(buf1, sizeof buf1);
memcpy(buf2, buf1, sizeof buf2);
printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
sodium_memzero(buf1, 0U);
printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
sodium_memzero(buf1, sizeof buf1 / 2);
printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
printf("%d\n", sodium_memcmp(buf1, buf2, 0U));
sodium_memzero(buf2, sizeof buf2 / 2);
printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
printf("%s\n",
sodium_bin2hex(buf3, 33U, (const unsigned char *)"0123456789ABCDEF",
16U));
hex = "Cafe : 6942";
sodium_hex2bin(buf4, sizeof buf4, hex, strlen(hex), ": ", &bin_len, &hex_end);
printf("%lu:%02x%02x%02x%02x\n", (unsigned long)bin_len, buf4[0], buf4[1],
buf4[2], buf4[3]);
printf("dt1: %ld\n", (long) (hex_end - hex));
hex = "Cafe : 6942";
sodium_hex2bin(buf4, sizeof buf4, hex, strlen(hex), ": ", &bin_len, NULL);
printf("%lu:%02x%02x%02x%02x\n", (unsigned long)bin_len, buf4[2], buf4[3],
buf4[2], buf4[3]);
hex = "deadbeef";
if (sodium_hex2bin(buf1, 1U, hex, 8U, NULL, &bin_len, &hex_end) != -1) {
printf("sodium_hex2bin() overflow not detected\n");
}
printf("dt2: %ld\n", (long) (hex_end - hex));
hex = "de:ad:be:eff";
if (sodium_hex2bin(buf1, 4U, hex, 12U, ":", &bin_len, &hex_end) != -1) {
printf("sodium_hex2bin() with an odd input length and a short output buffer\n");
}
printf("dt3: %ld\n", (long) (hex_end - hex));
hex = "de:ad:be:eff";
if (sodium_hex2bin(buf1, sizeof buf1, hex, 12U, ":", &bin_len, &hex_end) != 0) {
printf("sodium_hex2bin() with an odd input length\n");
}
printf("dt4: %ld\n", (long) (hex_end - hex));
hex = "de:ad:be:eff";
if (sodium_hex2bin(buf1, sizeof buf1, hex, 13U, ":", &bin_len, &hex_end) != 0) {
printf("sodium_hex2bin() with an odd input length\n");
}
printf("dt5: %ld\n", (long) (hex_end - hex));
return 0;
}
|
281677160/openwrt-package | 1,504 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/test/default/stream.c |
#define TEST_NAME "stream"
#include "cmptest.h"
unsigned char firstkey[32]
= { 0x1b, 0x27, 0x55, 0x64, 0x73, 0xe9, 0x85, 0xd4, 0x62, 0xcd, 0x51,
0x19, 0x7a, 0x9a, 0x46, 0xc7, 0x60, 0x09, 0x54, 0x9e, 0xac, 0x64,
0x74, 0xf2, 0x06, 0xc4, 0xee, 0x08, 0x44, 0xf6, 0x83, 0x89 };
unsigned char nonce[24] = { 0x69, 0x69, 0x6e, 0xe9, 0x55, 0xb6, 0x2b, 0x73,
0xcd, 0x62, 0xbd, 0xa8, 0x75, 0xfc, 0x73, 0xd6,
0x82, 0x19, 0xe0, 0x03, 0x6b, 0x7a, 0x0b, 0x37 };
unsigned char output[4194304];
unsigned char h[32];
int main(void)
{
int i;
crypto_stream(output, sizeof output, nonce, firstkey);
crypto_hash_sha256(h, output, sizeof output);
for (i = 0; i < 32; ++i)
printf("%02x", h[i]);
printf("\n");
assert(sizeof output > 4000);
crypto_stream_xsalsa20_xor_ic(output, output, 4000, nonce, 0U, firstkey);
for (i = 0; i < 4000; ++i)
assert(output[i] == 0);
crypto_stream_xsalsa20_xor_ic(output, output, 4000, nonce, 1U, firstkey);
crypto_hash_sha256(h, output, sizeof output);
for (i = 0; i < 32; ++i)
printf("%02x", h[i]);
printf("\n");
assert(crypto_stream_keybytes() > 0U);
assert(crypto_stream_noncebytes() > 0U);
assert(strcmp(crypto_stream_primitive(), "xsalsa20") == 0);
assert(crypto_stream_keybytes() == crypto_stream_xsalsa20_keybytes());
assert(crypto_stream_noncebytes() == crypto_stream_xsalsa20_noncebytes());
return 0;
}
|
281677160/openwrt-package | 3,890 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/test/default/box_easy2.c |
#define TEST_NAME "box_easy2"
#include "cmptest.h"
unsigned char m[10000];
unsigned char m2[10000];
unsigned char c[crypto_box_MACBYTES + 10000];
int main(void)
{
unsigned char *alicepk;
unsigned char *alicesk;
unsigned char *bobpk;
unsigned char *bobsk;
unsigned char *mac;
unsigned char *nonce;
unsigned char *k1;
unsigned char *k2;
size_t mlen;
size_t i;
alicepk = (unsigned char *) sodium_malloc(crypto_box_PUBLICKEYBYTES);
alicesk = (unsigned char *) sodium_malloc(crypto_box_SECRETKEYBYTES);
bobpk = (unsigned char *) sodium_malloc(crypto_box_PUBLICKEYBYTES);
bobsk = (unsigned char *) sodium_malloc(crypto_box_SECRETKEYBYTES);
mac = (unsigned char *) sodium_malloc(crypto_box_MACBYTES);
nonce = (unsigned char *) sodium_malloc(crypto_box_NONCEBYTES);
k1 = (unsigned char *) sodium_malloc(crypto_box_BEFORENMBYTES);
k2 = (unsigned char *) sodium_malloc(crypto_box_BEFORENMBYTES);
crypto_box_keypair(alicepk, alicesk);
crypto_box_keypair(bobpk, bobsk);
mlen = (size_t) randombytes_uniform((uint32_t)sizeof m);
randombytes_buf(m, mlen);
randombytes_buf(nonce, crypto_box_NONCEBYTES);
crypto_box_easy(c, m, mlen, nonce, bobpk, alicesk);
if (crypto_box_open_easy(m2, c,
(unsigned long long) mlen + crypto_box_MACBYTES,
nonce, alicepk, bobsk) != 0) {
printf("open() failed");
return 1;
}
printf("%d\n", memcmp(m, m2, mlen));
for (i = 0; i < mlen + crypto_box_MACBYTES - 1; i++) {
if (crypto_box_open_easy(m2, c, (unsigned long long) i,
nonce, alicepk, bobsk) == 0) {
printf("short open() should have failed");
return 1;
}
}
memcpy(c, m, mlen);
crypto_box_easy(c, c, (unsigned long long) mlen, nonce, bobpk, alicesk);
printf("%d\n", memcmp(m, c, mlen) == 0);
printf("%d\n", memcmp(m, c + crypto_box_MACBYTES, mlen) == 0);
if (crypto_box_open_easy(c, c,
(unsigned long long) mlen + crypto_box_MACBYTES,
nonce, alicepk, bobsk) != 0) {
printf("crypto_box_open_easy() failed\n");
}
crypto_box_beforenm(k1, alicepk, bobsk);
crypto_box_beforenm(k2, bobpk, alicesk);
memset(m2, 0, sizeof m2);
if (crypto_box_easy_afternm(c, m, SIZE_MAX - 1U, nonce, k1) == 0) {
printf("crypto_box_easy_afternm() with a short ciphertext should have failed\n");
}
crypto_box_easy_afternm(c, m, (unsigned long long) mlen, nonce, k1);
crypto_box_open_easy_afternm(m2, c,
(unsigned long long) mlen + crypto_box_MACBYTES,
nonce, k2);
printf("%d\n", memcmp(m, m2, mlen));
if (crypto_box_open_easy_afternm(m2, c, crypto_box_MACBYTES - 1U,
nonce, k2) == 0) {
printf("crypto_box_open_easy_afternm() with a huge ciphertext should have failed\n");
}
memset(m2, 0, sizeof m2);
crypto_box_detached(c, mac, m, (unsigned long long) mlen,
nonce, alicepk, bobsk);
crypto_box_open_detached(m2, c, mac, (unsigned long long) mlen,
nonce, bobpk, alicesk);
printf("%d\n", memcmp(m, m2, mlen));
memset(m2, 0, sizeof m2);
crypto_box_detached_afternm(c, mac, m, (unsigned long long) mlen,
nonce, k1);
crypto_box_open_detached_afternm(m2, c, mac, (unsigned long long) mlen,
nonce, k2);
printf("%d\n", memcmp(m, m2, mlen));
sodium_free(alicepk);
sodium_free(alicesk);
sodium_free(bobpk);
sodium_free(bobsk);
sodium_free(mac);
sodium_free(nonce);
sodium_free(k1);
sodium_free(k2);
printf("OK\n");
return 0;
}
|
281677160/openwrt-package | 1,375 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/test/default/wintest.bat | @ECHO OFF
if "%1" == "" (
echo "Usage: wintest.bat <Release | ReleaseDLL | Debug | DebugDLL"
goto :END
)
if not exist sodium_version.c (
CD test\default
if not exist sodium_version.c (
echo "Are you on the right path?" %CD%
goto :END
)
)
if "%2" == "x64" (SET ARCH=x64) else (SET ARCH=Win32)
SET CFLAGS=/nologo /DTEST_SRCDIR=\".\" /I..\..\src\libsodium\include\sodium /I..\..\src\libsodium\include /I..\quirks
SET LDFLAGS=/link /LTCG advapi32.lib ..\..\Build\%1\%ARCH%\libsodium.lib
if "%1" == "ReleaseDLL" ( goto :ReleaseDLL )
if "%1" == "DebugDLL" ( goto :DebugDLL )
if "%1" == "Release" ( goto :Release )
if "%1" == "Debug" ( goto :Debug )
echo "Invalid build type"
goto :END
:ReleaseDLL
SET CFLAGS=%CFLAGS% /MD /Ox
SET PATH=..\..\Build\%1\%ARCH%;%PATH%
goto :COMPILE
:Release
SET CFLAGS=%CFLAGS% /MT /Ox /DSODIUM_STATIC /DSODIUM_EXPORT=
goto :COMPILE
:DebugDLL
SET CFLAGS=%CFLAGS% /GS /MDd /Od
SET PATH=..\..\Build\%1\%ARCH%;%PATH%
goto :COMPILE
:Debug
SET CFLAGS=%CFLAGS% /GS /MTd /Od /DSODIUM_STATIC /DSODIUM_EXPORT=
goto :COMPILE
:COMPILE
echo Running the test suite:
FOR %%f in (*.c) DO (
cl %CFLAGS% %%f %LDFLAGS% /OUT:%%f.exe > NUL 2>&1
if not exist %%f.exe (
echo %%f compile failed
goto :END
)
%%f.exe
if errorlevel 1 (
echo %%f failed
) else (
echo %%f ok
)
)
REM Remove temporary files
del *.exe *.obj *.res
:END
|
281677160/openwrt-package | 1,056 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/test/default/secretbox7.c |
#define TEST_NAME "secretbox7"
#include "cmptest.h"
unsigned char k[crypto_secretbox_KEYBYTES];
unsigned char n[crypto_secretbox_NONCEBYTES];
unsigned char m[10000];
unsigned char c[10000];
unsigned char m2[10000];
int main(void)
{
size_t mlen;
size_t i;
for (mlen = 0; mlen < 1000 && mlen + crypto_secretbox_ZEROBYTES < sizeof m;
++mlen) {
randombytes_buf(k, crypto_secretbox_KEYBYTES);
randombytes_buf(n, crypto_secretbox_NONCEBYTES);
randombytes_buf(m + crypto_secretbox_ZEROBYTES, mlen);
crypto_secretbox(c, m, mlen + crypto_secretbox_ZEROBYTES, n, k);
if (crypto_secretbox_open(m2, c, mlen + crypto_secretbox_ZEROBYTES, n,
k) == 0) {
for (i = 0; i < mlen + crypto_secretbox_ZEROBYTES; ++i) {
if (m2[i] != m[i]) {
printf("bad decryption\n");
break;
}
}
} else {
printf("ciphertext fails verification\n");
}
}
return 0;
}
|
281677160/openwrt-package | 1,178 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/test/default/cmptest.h |
#ifndef __CMPTEST_H__
#define __CMPTEST_H__
#include <assert.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "sodium.h"
#include "quirks.h"
#ifdef __EMSCRIPTEN__
# undef TEST_SRCDIR
# define TEST_SRCDIR "/test-data"
#endif
#ifndef TEST_SRCDIR
# define TEST_SRCDIR "."
#endif
#define TEST_NAME_RES TEST_NAME ".res"
#define TEST_NAME_OUT TEST_SRCDIR "/" TEST_NAME ".exp"
#ifdef HAVE_ARC4RANDOM
# undef rand
# define rand(X) arc4random(X)
#endif
FILE *fp_res;
int xmain(void);
int main(void)
{
FILE *fp_out;
int c;
if ((fp_res = fopen(TEST_NAME_RES, "w+")) == NULL) {
perror("fopen(" TEST_NAME_RES ")");
return 99;
}
if (sodium_init() != 0) {
return 99;
}
if (xmain() != 0) {
return 99;
}
rewind(fp_res);
if ((fp_out = fopen(TEST_NAME_OUT, "r")) == NULL) {
perror("fopen(" TEST_NAME_OUT ")");
return 99;
}
do {
if ((c = fgetc(fp_res)) != fgetc(fp_out)) {
return 99;
}
} while (c != EOF);
return 0;
}
#undef printf
#define printf(...) fprintf(fp_res, __VA_ARGS__)
#define main xmain
#endif
|
2833844911/IPserver | 4,420 | README.md | ## 安卓客户端服务端代理工具
视频教程:
https://www.bilibili.com/video/BV1WJ4m1A78w/
工具可以实现代理池的搭建利用手机可以一直切ip,把手机（使用流量，不是wifi）作为类似拨号服务器,可以在我们需要过ip风控(利用手机切ip)的时候使用
### 下面的配置要服务端和客户端的配置一样
```json
{
"connectionName": "", // 无关 后续功能还在开发
"username": "", // 无关 后续功能还在开发
"password": "",// 无关 后续功能还在开发
"proxydk": 19191, // 安卓手机哪个端口作为代理端口
"cyBohao": 19687, // 安卓手机哪个端口作为拨号服务端口
"group": "cbb", // 设置这台手机属于什么组，方便后续根据组去获取代理 (不能为空) 为("all" )就在全部的代理中随机选择不会按照组去分类
"frpserverIp": "213.126.207.110", // 服务端的ip地址
"frpserverPort": 57001, // 服务端的frps端口 （记得开放这个端口 或者 关闭防火墙）
"serverPort": 9990, // 服务端的获取代理的端口 （记得开放这个端口 或者 关闭防火墙）
"frptoken": "64dcadf8108a9fc9d175778f31c6192f", // 服务端的token
"maxError": 3, // 服务端检测代理是否可以使用的次数(建议填多些) （超出次数判定这个代理不能使用 获取代理就不会获取到 需要重启客户端）
"qieHuanIpTime": 180, // 代理切换ip地址的时间间隔
"jiancTime": 60, // 服务端检测代理是否可以使用的时间间隔
"bohaosleepTime": 20, // 代理切换ip地址后多长时间可以使用该代理
"startPort": 20000, // 服务端的 代理端口范围 到下面的endProt （记得开放这个范围的端口 或者 关闭防火墙）
"endProt": 30000
}
```
## 服务端使用方法
1. 把压缩包里面的文件放入 centos的 目录下 这里我举例子放入 /data/ipServer
2. cd /data/ipServer 进入centos的目录
3. chmod +x ./main 给权限
4. ./main 启动
5. 启动后一定开放 frpserverPort serverPort 还有范围 startPort-endProt 的端口
### 服务端快速使用方法 （不想执行上面代理的话）
```sh
# curl -sSL https://ciyverify.com/serve/anzinstall.sh | sh -s 服务端外网地址 你的校验token(frptoken)
curl -sSL https://ciyverify.com/serve/anzinstall.sh | sh -s 127.0.0.1 hdakjsdhaskhnkcnzxck
```
启动后一定开放 57001 9990 还有范围 20000-21000 的端口 , 然后才可以部署客户端
## 安卓arm客户端使用方法
1. 把压缩包里面的文件放入 安卓的 /data/local/tmp 目录下
2. cd /data/local/tmp 进入安卓的目录
3. chmod +x ./main 给权限
4. ./main 启动 (启动前要确保服务端已经开启了)
### 安卓arm客户端快速使用方法 （不想执行上面代理的话）
进入 /data/local/tmp 目录下
```sh
cd /data/local/tmp
# curl -sSL https://ciyverify.com/anzzzzz/anzinstall.sh | sh -s 服务端外网地址 你的校验token(frptoken)
curl -sSL https://ciyverify.com/anzzzzz/anzinstall.sh | sh -s 127.0.0.1 hdakjsdhaskhnkcnzxck
```
## 拨号centos客户端使用方法 (用pppoe-start 和 pppoe-stop 去拨号的)
1. 把压缩包里面的文件放入 安卓的 /data/cyIp 目录下
2. cd /data/cyIp 进入安卓的目录
3. chmod +x ./main 给权限
4. ./main 启动 (启动前要确保服务端已经开启了)
### 安卓arm客户端快速使用方法 （不想执行上面代理的话）
```sh
# curl -sSL https://ciyverify.com/cento/anzinstall.sh | sh -s 服务端外网地址 你的校验token(frptoken)
curl -sSL https://ciyverify.com/cento/anzinstall.sh | sh -s 127.0.0.1 hdakjsdhaskhnkcnzxck
```
## 从代理池中获取ip代理
```python
# url = "http://服务端ip:服务端的获取代理的端口/getProxy/服务端的token/组"
url = "http://213.126.207.110:9990/getProxy/5779264dcad8f31c61f8108a9fc9d17f/cbb"
response = requests.get(url)
print(response.text)
# {"proxy":"kz7LUHAk-0xNTQ==:SI1T6KkoFchY3g==@127.0.0.1:20000","code":200}
```
## 从代理池所有节点配置
```python
# url = "http://服务端ip:服务端的获取代理的端口/getConfig/服务端的token"
url = "http://213.126.207.110:9990/getConfig/5779264dcad8f31c61f8108a9fc9d17f"
response = requests.get(url,
)
print(response.text)
# {"code":200,"data":[{"proxyPort":20000,"id":"23288566-fd00-40c3-ad27-66470f5c7698","addr":"127.0.0.1","group":"cbb","token":"KhLBooCCJRFGorQv1QlKCpJA3PhaWtoN","serverPort":20001,"serverProxyIp":"127.0.0.1","nameInfo":"kz7LUHAk-0xNTQ==","password":"SI1T6KkoFchY3g=="}]}
```
## 把别人的节点添加到自己的代理池中
```python
import requests
url = "http://127.0.0.1:9990/pushIpConfig/5779264dcad8f31c61f8108a9fc9d17f"
response = requests.post(url,
json=[{"proxyPort":20000,"id":"0fb283c7-b376-4a40-ba33-cbfe5e1aa95a","addr":"106.228.116.174","group":"cbb","token":"uwTiYpM9RbLmKG81_uLZdujgIW_6yz7U","serverPort":20001,"serverProxyIp":"221.227.122.182","nameInfo":"unaGF5Nm6wgSLA==","password":"t_hKzQhs9CFUnQ=="},{"proxyPort":20002,"id":"d35be4ed-41aa-4911-8690-34dc041203e3","addr":"117.57.74.213","group":"cbb","token":"JkbpAqgjhuf6iIXAnIDGU6xATVPzY9bZ","serverPort":20003,"serverProxyIp":"221.227.122.182","nameInfo":"Ujqs9dCsZOx3ng==","password":"pLoeBRC1va_TiQ=="},{"proxyPort":20004,"id":"c1df20cb-eadf-43d3-9136-b5baa2d37fbf","addr":"59.58.47.73","group":"cbb","token":"_vfuUwcDY4lUhySomDqNIRxJUQsoDbtP","serverPort":20005,"serverProxyIp":"221.227.122.182","nameInfo":"pBuShX7c1RikcQ==","password":"3HFmoeqHJrq7fw=="},{"proxyPort":20008,"id":"1e2843f6-95c4-474d-a4e7-fc9184eb833d","addr":"116.7.198.237","group":"cbb","token":"eEGanyiMrWByhbvbYuuNPuayHBK7EWct","serverPort":20009,"serverProxyIp":"221.227.122.182","nameInfo":"cWvBR7CtnekkVQ==","password":"jJw22hIr-gpEFg=="}]
)
print(response.text)
# okk
```
### 知识星球 交流讨论爬虫技术
https://t.zsxq.com/194IAl5UN
|
2833844911/IPserver | 1,056 | 服务端centos/anzinstall.sh | #!/bin/bash
# 要检查的文件列表
files=("./main" "./frps" "./start.sh")
# 标志变量，初始值为0表示所有文件都存在
all_files_exist=1
curl -O "https://ciyverify.com/serve/config.json"
# 检查每个文件是否存在
for file in "${files[@]}"; do
if [ ! -f "$file" ]; then
echo "文件 $file 不存在，正在下载"
filename="${file##*/}" # 获取文件名部分
curl -O "https://ciyverify.com/serve/$filename"
all_files_exist=0
fi
done
CONFIG_FILE="config.json"
OLD_VALUE="127.0.0.1"
NEW_VALUE="$1"
sed -i "s/${OLD_VALUE}/${NEW_VALUE}/g" "$CONFIG_FILE"
OLD_VALUE2="ad8f31c61f815779264dc08a9fc9d17f"
NEW_VALUE2="$2"
sed -i "s/${OLD_VALUE2}/${NEW_VALUE2}/g" "$CONFIG_FILE"
chmod +x start.sh
./start.sh
# 提示所有文件存在
if [ $all_files_exist -eq 1 ]; then
echo "所有文件都存在。"
fi
# 需要 root 权限执行此脚本
if [ "$(id -u)" -ne 0 ]; then
echo "Please run as root"
exit 1
fi
# 定义要开放的端口
PORTS=("57001" "9990" "20000:21000")
# 开放端口
for PORT in "${PORTS[@]}"; do
iptables -A INPUT -p tcp --dport $PORT -j ACCEPT
iptables -A INPUT -p udp --dport $PORT -j ACCEPT
done
# shellcheck disable=SC2145
echo "Ports ${PORTS[@]} opened." |
281677160/openwrt-package | 1,436 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/test/default/onetimeauth2.c |
#define TEST_NAME "onetimeauth2"
#include "cmptest.h"
unsigned char rs[32]
= { 0xee, 0xa6, 0xa7, 0x25, 0x1c, 0x1e, 0x72, 0x91, 0x6d, 0x11, 0xc2,
0xcb, 0x21, 0x4d, 0x3c, 0x25, 0x25, 0x39, 0x12, 0x1d, 0x8e, 0x23,
0x4e, 0x65, 0x2d, 0x65, 0x1f, 0xa4, 0xc8, 0xcf, 0xf8, 0x80 };
unsigned char c[131]
= { 0x8e, 0x99, 0x3b, 0x9f, 0x48, 0x68, 0x12, 0x73, 0xc2, 0x96, 0x50, 0xba,
0x32, 0xfc, 0x76, 0xce, 0x48, 0x33, 0x2e, 0xa7, 0x16, 0x4d, 0x96, 0xa4,
0x47, 0x6f, 0xb8, 0xc5, 0x31, 0xa1, 0x18, 0x6a, 0xc0, 0xdf, 0xc1, 0x7c,
0x98, 0xdc, 0xe8, 0x7b, 0x4d, 0xa7, 0xf0, 0x11, 0xec, 0x48, 0xc9, 0x72,
0x71, 0xd2, 0xc2, 0x0f, 0x9b, 0x92, 0x8f, 0xe2, 0x27, 0x0d, 0x6f, 0xb8,
0x63, 0xd5, 0x17, 0x38, 0xb4, 0x8e, 0xee, 0xe3, 0x14, 0xa7, 0xcc, 0x8a,
0xb9, 0x32, 0x16, 0x45, 0x48, 0xe5, 0x26, 0xae, 0x90, 0x22, 0x43, 0x68,
0x51, 0x7a, 0xcf, 0xea, 0xbd, 0x6b, 0xb3, 0x73, 0x2b, 0xc0, 0xe9, 0xda,
0x99, 0x83, 0x2b, 0x61, 0xca, 0x01, 0xb6, 0xde, 0x56, 0x24, 0x4a, 0x9e,
0x88, 0xd5, 0xf9, 0xb3, 0x79, 0x73, 0xf6, 0x22, 0xa4, 0x3d, 0x14, 0xa6,
0x59, 0x9b, 0x1f, 0x65, 0x4c, 0xb4, 0x5a, 0x74, 0xe3, 0x55, 0xa5 };
unsigned char a[16] = { 0xf3, 0xff, 0xc7, 0x70, 0x3f, 0x94, 0x00, 0xe5,
0x2a, 0x7d, 0xfb, 0x4b, 0x3d, 0x33, 0x05, 0xd9 };
int main(void)
{
printf("%d\n", crypto_onetimeauth_verify(a, c, 131, rs));
return 0;
}
|
281677160/openwrt-package | 1,201 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/test/default/box7.c |
#define TEST_NAME "box7"
#include "cmptest.h"
unsigned char alicesk[crypto_box_SECRETKEYBYTES];
unsigned char alicepk[crypto_box_PUBLICKEYBYTES];
unsigned char bobsk[crypto_box_SECRETKEYBYTES];
unsigned char bobpk[crypto_box_PUBLICKEYBYTES];
unsigned char n[crypto_box_NONCEBYTES];
unsigned char m[10000];
unsigned char c[10000];
unsigned char m2[10000];
int main(void)
{
size_t mlen;
size_t i;
for (mlen = 0; mlen < 1000 && mlen + crypto_box_ZEROBYTES < sizeof m;
++mlen) {
crypto_box_keypair(alicepk, alicesk);
crypto_box_keypair(bobpk, bobsk);
randombytes_buf(n, crypto_box_NONCEBYTES);
randombytes_buf(m + crypto_box_ZEROBYTES, mlen);
crypto_box(c, m, mlen + crypto_box_ZEROBYTES, n, bobpk, alicesk);
if (crypto_box_open(m2, c, mlen + crypto_box_ZEROBYTES, n, alicepk,
bobsk) == 0) {
for (i = 0; i < mlen + crypto_box_ZEROBYTES; ++i) {
if (m2[i] != m[i]) {
printf("bad decryption\n");
break;
}
}
} else {
printf("ciphertext fails verification\n");
}
}
return 0;
}
|
281677160/openwrt-package | 1,211 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/test/default/secretbox8.c |
#define TEST_NAME "secretbox8"
#include "cmptest.h"
unsigned char k[crypto_secretbox_KEYBYTES];
unsigned char n[crypto_secretbox_NONCEBYTES];
unsigned char m[10000];
unsigned char c[10000];
unsigned char m2[10000];
int main(void)
{
size_t mlen;
size_t i;
int caught;
for (mlen = 0; mlen < 1000 && mlen + crypto_secretbox_ZEROBYTES < sizeof m;
++mlen) {
randombytes_buf(k, crypto_secretbox_KEYBYTES);
randombytes_buf(n, crypto_secretbox_NONCEBYTES);
randombytes_buf(m + crypto_secretbox_ZEROBYTES, mlen);
crypto_secretbox(c, m, mlen + crypto_secretbox_ZEROBYTES, n, k);
caught = 0;
while (caught < 10) {
c[rand() % (mlen + crypto_secretbox_ZEROBYTES)] = rand();
if (crypto_secretbox_open(m2, c, mlen + crypto_secretbox_ZEROBYTES,
n, k) == 0) {
for (i = 0; i < mlen + crypto_secretbox_ZEROBYTES; ++i) {
if (m2[i] != m[i]) {
printf("forgery\n");
return 100;
}
}
} else {
++caught;
}
}
}
return 0;
}
|
281677160/openwrt-package | 1,040 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/test/default/auth3.c | /* "Test Case AUTH256-4" from RFC 4868 */
#define TEST_NAME "auth3"
#include "cmptest.h"
unsigned char key[32]
= { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20 };
unsigned char c[50]
= { 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd };
unsigned char a[32]
= { 0x37, 0x2e, 0xfc, 0xf9, 0xb4, 0x0b, 0x35, 0xc2, 0x11, 0x5b, 0x13,
0x46, 0x90, 0x3d, 0x2e, 0xf4, 0x2f, 0xce, 0xd4, 0x6f, 0x08, 0x46,
0xe7, 0x25, 0x7b, 0xb1, 0x56, 0xd3, 0xd7, 0xb3, 0x0d, 0x3f };
int main(void)
{
printf("%d\n", crypto_auth_hmacsha256_verify(a, c, sizeof c, key));
return 0;
}
|
281677160/openwrt-package | 2,777 | luci-app-ssr-plus/shadowsocksr-libev/src/libsodium/test/default/secretbox.c |
#define TEST_NAME "secretbox"
#include "cmptest.h"
unsigned char firstkey[32]
= { 0x1b, 0x27, 0x55, 0x64, 0x73, 0xe9, 0x85, 0xd4, 0x62, 0xcd, 0x51,
0x19, 0x7a, 0x9a, 0x46, 0xc7, 0x60, 0x09, 0x54, 0x9e, 0xac, 0x64,
0x74, 0xf2, 0x06, 0xc4, 0xee, 0x08, 0x44, 0xf6, 0x83, 0x89 };
unsigned char nonce[24] = { 0x69, 0x69, 0x6e, 0xe9, 0x55, 0xb6, 0x2b, 0x73,
0xcd, 0x62, 0xbd, 0xa8, 0x75, 0xfc, 0x73, 0xd6,
0x82, 0x19, 0xe0, 0x03, 0x6b, 0x7a, 0x0b, 0x37 };
// API requires first 32 bytes to be 0
unsigned char m[163]
= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0xbe, 0x07, 0x5f, 0xc5,
0x3c, 0x81, 0xf2, 0xd5, 0xcf, 0x14, 0x13, 0x16, 0xeb, 0xeb, 0x0c, 0x7b,
0x52, 0x28, 0xc5, 0x2a, 0x4c, 0x62, 0xcb, 0xd4, 0x4b, 0x66, 0x84, 0x9b,
0x64, 0x24, 0x4f, 0xfc, 0xe5, 0xec, 0xba, 0xaf, 0x33, 0xbd, 0x75, 0x1a,
0x1a, 0xc7, 0x28, 0xd4, 0x5e, 0x6c, 0x61, 0x29, 0x6c, 0xdc, 0x3c, 0x01,
0x23, 0x35, 0x61, 0xf4, 0x1d, 0xb6, 0x6c, 0xce, 0x31, 0x4a, 0xdb, 0x31,
0x0e, 0x3b, 0xe8, 0x25, 0x0c, 0x46, 0xf0, 0x6d, 0xce, 0xea, 0x3a, 0x7f,
0xa1, 0x34, 0x80, 0x57, 0xe2, 0xf6, 0x55, 0x6a, 0xd6, 0xb1, 0x31, 0x8a,
0x02, 0x4a, 0x83, 0x8f, 0x21, 0xaf, 0x1f, 0xde, 0x04, 0x89, 0x77, 0xeb,
0x48, 0xf5, 0x9f, 0xfd, 0x49, 0x24, 0xca, 0x1c, 0x60, 0x90, 0x2e, 0x52,
0xf0, 0xa0, 0x89, 0xbc, 0x76, 0x89, 0x70, 0x40, 0xe0, 0x82, 0xf9, 0x37,
0x76, 0x38, 0x48, 0x64, 0x5e, 0x07, 0x05 };
unsigned char c[163];
int main(void)
{
int i;
crypto_secretbox(c, m, 163, nonce, firstkey);
for (i = 16; i < 163; ++i) {
printf(",0x%02x", (unsigned int)c[i]);
if (i % 8 == 7)
printf("\n");
}
printf("\n");
assert(crypto_secretbox_keybytes() > 0U);
assert(crypto_secretbox_noncebytes() > 0U);
assert(crypto_secretbox_zerobytes() > 0U);
assert(crypto_secretbox_boxzerobytes() > 0U);
assert(crypto_secretbox_macbytes() > 0U);
assert(strcmp(crypto_secretbox_primitive(), "xsalsa20poly1305") == 0);
assert(crypto_secretbox_keybytes()
== crypto_secretbox_xsalsa20poly1305_keybytes());
assert(crypto_secretbox_noncebytes()
== crypto_secretbox_xsalsa20poly1305_noncebytes());
assert(crypto_secretbox_zerobytes()
== crypto_secretbox_xsalsa20poly1305_zerobytes());
assert(crypto_secretbox_boxzerobytes()
== crypto_secretbox_xsalsa20poly1305_boxzerobytes());
assert(crypto_secretbox_macbytes()
== crypto_secretbox_xsalsa20poly1305_macbytes());
return 0;
}
|
Subsets and Splits
PyTorch Neural Network Imports
This query filters for code examples containing a specific PyTorch import pattern, which is useful for finding code snippets that use PyTorch's neural network module but doesn't provide deeper analytical insights about the dataset.
HTML Files in Train Set
Retrieves all records from the dataset where the file path ends with .html or .htm, providing a basic filter for HTML files.
SQL Console for nick007x/github-code-2025
Retrieves 200 file paths that end with '.html' or '.htm', providing a basic overview of HTML files in the dataset.
Top HTML Files
The query retrieves a sample of HTML file paths, providing basic filtering but limited analytical value.
CSharp Repositories Excluding Unity
Retrieves all records for repositories that contain C# files but are not related to Unity, providing a basic filter of the dataset.
C# File Count per Repository
Counts the total number of C# files across distinct repositories, providing a basic measure of C# file presence.
SQL Console for nick007x/github-code-2025
Lists unique repository IDs containing C# files, providing basic filtering to understand which repositories have C# code.
Select Groovy Files: Train Set
Retrieves the first 1000 entries from the 'train' dataset where the file path ends with '.groovy', providing a basic sample of Groovy files.
GitHub Repos with WiFiClientSecure
Finds specific file paths in repositories that contain particular code snippets related to WiFiClientSecure and ChatGPT, providing basic filtering of relevant files.