pidgin3: comparison libpurple/protocols/zephyr/Zinternal.c

-:9d1565e94617
+:2e4624a59df5
 /* Find or insert uid in the old uids buffer.  The buffer is a sorted
 * circular queue.  We make the assumption that most packets arrive in
 * order, so we can usually search for a uid or insert it into the buffer
 * by looking back just a few entries from the end.  Since this code is
 * only executed by the client, the implementation isn't microoptimized. */
-static int find_or_insert_uid(uid, kind)
+static int
-ZUnique_Id_t *uid;
+find_or_insert_uid(ZUnique_Id_t *uid, ZNotice_Kind_t kind)
-ZNotice_Kind_t kind;
 {
 static struct _filter {
 	ZUnique_Id_t	uid;
 	ZNotice_Kind_t	kind;
 	time_t		t;
 }
 /* Read any available packets and enqueue them */
-Code_t Z_ReadEnqueue()
+Code_t
+Z_ReadEnqueue(void)
 {
 Code_t retval;
 if (ZGetFD() < 0)
 	return (ZERR_NOPORT);
 *
 * This routine does NOT guarantee a complete packet will be ready when it
 * returns.
 */
-Code_t Z_ReadWait()
+Code_t
+Z_ReadWait(void)
 {
 register struct _Z_InputQ *qptr;
 ZNotice_t notice;
 ZPacket_t packet;
 struct sockaddr_in olddest, from;
 }
 /* Fragment management routines - compliments, more or less, of RFC815 */
-Code_t Z_AddNoticeToEntry(qptr, notice, part)
+Code_t
-struct _Z_InputQ *qptr;
+Z_AddNoticeToEntry(struct _Z_InputQ *qptr, ZNotice_t *notice, int part)
-ZNotice_t *notice;
-int part;
 {
 int last, oldfirst, oldlast;
 struct _Z_Hole *hole, *lasthole;
 struct timeval tv;
 }
 return (ZERR_NONE);
 }
-Code_t Z_FormatHeader(notice, buffer, buffer_len, len, cert_routine)
+Code_t
-ZNotice_t *notice;
+Z_FormatHeader(ZNotice_t *notice, char *buffer, int buffer_len, int *len,
-char *buffer;
+Z_AuthProc cert_routine)
-int buffer_len;
-int *len;
-Z_AuthProc cert_routine;
 {
 Code_t retval;
 static char version[BUFSIZ]; /* default init should be all \0 */
 struct sockaddr_in name;
 socklen_t namelen = sizeof(name);
 notice->z_version = version;
 return Z_FormatAuthHeader(notice, buffer, buffer_len, len, cert_routine);
 }
-Code_t Z_FormatAuthHeader(notice, buffer, buffer_len, len, cert_routine)
+Code_t
-ZNotice_t *notice;
+Z_FormatAuthHeader(ZNotice_t *notice, char *buffer, int buffer_len, int *len,
-char *buffer;
+Z_AuthProc cert_routine)
-int buffer_len;
-int *len;
-Z_AuthProc cert_routine;
 {
 if (!cert_routine) {
 	notice->z_auth = 0;
 	notice->z_authent_len = 0;
 	notice->z_ascii_authent = "";
 }
 return ((*cert_routine)(notice, buffer, buffer_len, len));
 }
-Code_t Z_FormatRawHeader(notice, buffer, buffer_len, len, cstart, cend)
+Code_t
-ZNotice_t *notice;
+Z_FormatRawHeader(ZNotice_t *notice, char *buffer, gsize buffer_len, int *len,
-char *buffer;
+char **cstart, char **cend)
-gsize buffer_len;
-int *len;
-char **cstart, **cend;
 {
 char newrecip[BUFSIZ];
 char *ptr, *end;
 int i;
 *ptr += len;
 return 0;
 }
-struct _Z_InputQ *Z_GetFirstComplete()
+struct _Z_InputQ *
+Z_GetFirstComplete(void)
 {
 struct _Z_InputQ *qptr;
 qptr = __Q_Head;
 }
 return ((struct _Z_InputQ *)0);
 }
-struct _Z_InputQ *Z_GetNextComplete(qptr)
+struct _Z_InputQ *
-struct _Z_InputQ *qptr;
+Z_GetNextComplete(struct _Z_InputQ *qptr)
 {
 qptr = qptr->next;
 while (qptr) {
 	if (qptr->complete)
 	    return (qptr);
 }
 return ((struct _Z_InputQ *)0);
 }
-void Z_RemQueue(qptr)
+void
-struct _Z_InputQ *qptr;
+Z_RemQueue(struct _Z_InputQ *qptr)
 {
 struct _Z_Hole *hole, *nexthole;
 if (qptr->complete)
 	__Q_CompleteLength--;
 qptr->next->prev = qptr->prev;
 free ((char *)qptr);
 return;
 }
-Code_t Z_SendFragmentedNotice(notice, len, cert_func, send_func)
+Code_t
-ZNotice_t *notice;
+Z_SendFragmentedNotice(ZNotice_t *notice, int len, Z_AuthProc cert_func,
-int len;
+Z_SendProc send_func)
-Z_AuthProc cert_func;
-Z_SendProc send_func;
 {
 ZNotice_t partnotice;
 ZPacket_t buffer;
 char multi[64];
 int offset, hdrsize, fragsize, ret_len, message_len, waitforack;
 return (ZERR_NONE);
 }
 /*ARGSUSED*/
-Code_t Z_XmitFragment(notice, buf, len, wait)
+Code_t
-ZNotice_t *notice;
+Z_XmitFragment(ZNotice_t *notice, char *buf, int len, int wait)
-char *buf;
-int len;
-int wait;
 {
 	return(ZSendPacket(buf, len, wait));
 }
 #ifdef Z_DEBUG
 (*__Z_debug_print) (format, pvar, __Z_debug_print_closure);
 va_end (pvar);
 }
 #endif
-void Z_debug_stderr (format, args, closure)
+void
-const char *format;
+Z_debug_stderr(const char *format, va_list args, void *closure)
-va_list args;
-void *closure;
 {
 #ifdef HAVE_VPRINTF
 vfprintf (stderr, format, args);
 #else
 _doprnt (format, args, stderr);
 #endif
 putc ('\n', stderr);
 }
 #undef ZGetFD
-int ZGetFD () { return __Zephyr_fd; }
+int
+ZGetFD(void)
+{
+	return __Zephyr_fd;
+}
 #undef ZQLength
-int ZQLength () { return __Q_CompleteLength; }
+int
+ZQLength(void)
+{
+	return __Q_CompleteLength;
+}
 #undef ZGetDestAddr
-struct sockaddr_in ZGetDestAddr () { return __HM_addr; }
+struct sockaddr_in
+ZGetDestAddr(void)
+{
+	return __HM_addr;
+}
 #undef ZGetRealm
-Zconst char * ZGetRealm () { return __Zephyr_realm; }
+Zconst char *
+ZGetRealm(void)
+{
+	return __Zephyr_realm;
+}
 #undef ZSetDebug
-void ZSetDebug(proc, arg)
+void
-void (*proc) __P((const char *, va_list, void *));
+ZSetDebug(void (*proc) __P((const char *, va_list, void *)), char *arg)
-char *arg;
 {
 __Z_debug_print = proc;
 __Z_debug_print_closure = arg;
 }
 #endif /* Z_DEBUG */

Mercurial > pidgin3 / file comparison

comparison: libpurple/protocols/zephyr/Zinternal.c

libpurple/protocols/zephyr/Zinternal.c