moparisthebest/curl
1
0
Fork 0
mirror of https://github.com/moparisthebest/curl synced 2025-02-28 17:31:46 -05:00
Code Issues Releases Wiki Activity

checksrc: Fixed line length and comment indentation

Browse Source
This commit is contained in:
Marc Hoersken 2012-09-14 00:44:16 +02:00
parent f73a27cadc
commit 8a2be299f4
3 changed files with 84 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
lib/nwlib.c
View File

@ -55,9 +55,9 @@ rtag_t gAllocTag = (rtag_t) NULL;
NXMutex_t *gLibLock = (NXMutex_t *) NULL;
/* internal library function prototypes... */
int DisposeLibraryData ( void * );
void DisposeThreadData ( void * );
int GetOrSetUpData ( int id, libdata_t **data, libthreaddata_t **threaddata );
int DisposeLibraryData( void * );
void DisposeThreadData( void * );
int GetOrSetUpData( int id, libdata_t **data, libthreaddata_t **threaddata );
int _NonAppStart( void *NLMHandle,
@ -90,12 +90,12 @@ int _NonAppStart( void *NLMHandle,
#pragma unused(messages)
#endif
/*
** Here we process our command line, post errors (to the error screen),
** perform initializations and anything else we need to do before being able
** to accept calls into us. If we succeed, we return non-zero and the NetWare
** Loader will leave us up, otherwise we fail to load and get dumped.
*/
/*
* Here we process our command line, post errors (to the error screen),
* perform initializations and anything else we need to do before being able
* to accept calls into us. If we succeed, we return non-zero and the NetWare
* Loader will leave us up, otherwise we fail to load and get dumped.
*/
gAllocTag = AllocateResourceTag(NLMHandle,
"<library-name> memory allocations",
AllocSignature);
@ -126,9 +126,9 @@ int _NonAppStart( void *NLMHandle,
}
/*
** Here we clean up any resources we allocated. Resource tags is a big part
** of what we created, but NetWare doesn't ask us to free those.
*/
* Here we clean up any resources we allocated. Resource tags is a big part
* of what we created, but NetWare doesn't ask us to free those.
*/
void _NonAppStop( void )
{
(void) unregister_library(gLibId);
@ -136,16 +136,16 @@ void _NonAppStop( void )
}
/*
** This function cannot be the first in the file for if the file is linked
** first, then the check-unload function's offset will be nlmname.nlm+0
** which is how to tell that there isn't one. When the check function is
** first in the linked objects, it is ambiguous. For this reason, we will
** put it inside this file after the stop function.
**
** Here we check to see if it's alright to ourselves to be unloaded. If not,
** we return a non-zero value. Right now, there isn't any reason not to allow
** it.
*/
* This function cannot be the first in the file for if the file is linked
* first, then the check-unload function's offset will be nlmname.nlm+0
* which is how to tell that there isn't one. When the check function is
* first in the linked objects, it is ambiguous. For this reason, we will
* put it inside this file after the stop function.
*
* Here we check to see if it's alright to ourselves to be unloaded. If not,
* we return a non-zero value. Right now, there isn't any reason not to allow
* it.
*/
int _NonAppCheckUnload( void )
{
return 0;
@ -163,22 +163,22 @@ int GetOrSetUpData(int id, libdata_t **appData,
err = 0;
thread_data = (libthreaddata_t *) NULL;
/*
** Attempt to get our data for the application calling us. This is where we
** store whatever application-specific information we need to carry in support
** of calling applications.
*/
/*
* Attempt to get our data for the application calling us. This is where we
* store whatever application-specific information we need to carry in
* support of calling applications.
*/
app_data = (libdata_t *) get_app_data(id);
if(!app_data) {
/*
** This application hasn't called us before; set up application AND per-thread
** data. Of course, just in case a thread from this same application is calling
** us simultaneously, we better lock our application data-creation mutex. We
** also need to recheck for data after we acquire the lock because WE might be
** that other thread that was too late to create the data and the first thread
** in will have created it.
*/
/*
* This application hasn't called us before; set up application AND
* per-thread data. Of course, just in case a thread from this same
* application is calling us simultaneously, we better lock our application
* data-creation mutex. We also need to recheck for data after we acquire
* the lock because WE might be that other thread that was too late to
* create the data and the first thread in will have created it.
*/
NXLock(gLibLock);
if(!(app_data = (libdata_t *) get_app_data(id))) {
@ -200,13 +200,14 @@ int GetOrSetUpData(int id, libdata_t **appData,
}
if(app_data) {
/*
** Here we burn in the application data that we were trying to get by calling
** get_app_data(). Next time we call the first function, we'll get this data
** we're just now setting. We also go on here to establish the per-thread data
** for the calling thread, something we'll have to do on each application
** thread the first time it calls us.
*/
/*
* Here we burn in the application data that we were trying to get
* by calling get_app_data(). Next time we call the first function,
* we'll get this data we're just now setting. We also go on here to
* establish the per-thread data for the calling thread, something
* we'll have to do on each application thread the first time
* it calls us.
*/
err = set_app_data(gLibId, app_data);
if(err) {
@ -236,13 +237,13 @@ int GetOrSetUpData(int id, libdata_t **appData,
if(key != -1 /* couldn't create a key? no thread data */
&& !(err = NXKeyGetValue(key, (void **) &thread_data))
&& !thread_data) {
/*
** Allocate the per-thread data for the calling thread. Regardless of whether
** there was already application data or not, this may be the first call by a
** a new thread. The fact that we allocation 20 bytes on a pointer is not very
** important, this just helps to demonstrate that we can have arbitrarily
** complex per-thread data.
*/
/*
* Allocate the per-thread data for the calling thread. Regardless of
* whether there was already application data or not, this may be the
* first call by a new thread. The fact that we allocation 20 bytes on
* a pointer is not very important, this just helps to demonstrate that
* we can have arbitrarily complex per-thread data.
*/
thread_data = malloc(sizeof(libthreaddata_t));
if(thread_data) {

6
lib/socks.c
View File

@ -562,7 +562,7 @@ CURLcode Curl_SOCKS5(const char *proxy_name,
if(!socks5_resolve_local) {
socksreq[len++] = 3; /* ATYP: domain name = 3 */
socksreq[len++] = (char) hostname_len; /* address length */
memcpy(&socksreq[len], hostname, hostname_len); /* address bytes w/o NULL */
memcpy(&socksreq[len], hostname, hostname_len); /* address str w/o NULL */
len += hostname_len;
}
else {
@ -592,7 +592,7 @@ CURLcode Curl_SOCKS5(const char *proxy_name,
int i;
if(hp->ai_family == AF_INET) {
socksreq[len++] = 1; /* IPv4 = 1 */
socksreq[len++] = 1; /* ATYP: IPv4 = 1 */
saddr_in = (struct sockaddr_in*)hp->ai_addr;
for(i = 0; i < 4; i++) {
@ -601,7 +601,7 @@ CURLcode Curl_SOCKS5(const char *proxy_name,
}
}
else if(hp->ai_family == AF_INET6) {
socksreq[len++] = 4; /* IPv6 = 4 */
socksreq[len++] = 4; /* ATYP: IPv6 = 4 */
saddr_in6 = (struct sockaddr_in6*)hp->ai_addr;
for(i = 0; i < 16; i++) {