4 small items in this:

- when we don't have in_addr_t, use uint32.
- a forgotten initialization of slave_proxy_id in sql/log_event.cc (was not really "forgot", was
"we needn't init it there", but there was one case where we needed...).
- made slave_proxy_id always meaningful in THD and Log_event, so we can
rely more on it (no need to test if it's meaningful). THD::slave_proxy_id
is equal to THD::thread_id except for the slave SQL thread.
- clean up the slave's temporary table (i.e. free their memory) when slave
server shuts down.


extra/resolveip.c:
  removed #define as it is simpler to put it in my_net.h
  (because we need the #define elsewhere)
include/my_net.h:
  When in_addr_t is not defined, use uint32.
libmysql/libmysql.c:
  using in_addr_t is more generic.
libmysql/manager.c:
  using in_addr_t is more generic.
mysql-test/t/rpl_chain_temp_table.test:
  comments
sql/log_event.cc:
  * Had forgot to initialize slave_proxy_id in the event constructor (char* buf...).
  Initializing is in fact only needed for Create_file_log_event, because
  it uses slave_proxy_id even if it does not write an event to the binlog
  (it uses slave_proxy_id to write it to SQL-LOAD.info).
  * When we write events we now always write slave_proxy_id, which is now always
  meaningful (as thd->slave_proxy_id is now always meaningful, see change in
  sql_class.cc).
sql/mini_client.cc:
  in_addr_t is more generic.
sql/slave.cc:
  A RELAY_LOG_INFO method to free the slave's temporary tables from memory
  at slave's server shutdown.
  It is called by end_slave(), which is called by close_connections(),
  which is called when the server terminates
  (close_connections() is just before clean_up(); putting the call in 
  clean_up() was buggy, as active_mi is already deleted by close_connections().
sql/slave.h:
  new method
sql/sql_class.cc:
  By default we set THD::slave_proxy_id to THD::thread_id,
  so THD::slave_proxy_id is always meaningful (not 0).
  It's always the same as the thread id except for the slave
  SQL thread.

sql/log_event.cc

@@ -874,7 +874,7 @@ Query_log_event::Query_log_event(const char* buf, int event_len,
     return;
 
   memcpy(data_buf, buf + Q_DATA_OFFSET, data_len);
-  thread_id = uint4korr(buf + Q_THREAD_ID_OFFSET);
+  slave_proxy_id= thread_id= uint4korr(buf + Q_THREAD_ID_OFFSET);
   db = data_buf;
   db_len = (uint)buf[Q_DB_LEN_OFFSET];
   query=data_buf + db_len + 1;
@@ -955,8 +955,7 @@ int Query_log_event::write_data(IO_CACHE* file)
     SET PSEUDO_THREAD_ID=
     for each query using temp tables.
   */
-  int4store(buf + Q_THREAD_ID_OFFSET, (slave_proxy_id ? slave_proxy_id :
-                                       thread_id));
+  int4store(buf + Q_THREAD_ID_OFFSET, slave_proxy_id);
   int4store(buf + Q_EXEC_TIME_OFFSET, exec_time);
   buf[Q_DB_LEN_OFFSET] = (char) db_len;
   int2store(buf + Q_ERR_CODE_OFFSET, error_code);
@@ -1057,8 +1056,7 @@ void Rand_log_event::print(FILE* file, bool short_form, char* last_db)
 int Load_log_event::write_data_header(IO_CACHE* file)
 {
   char buf[LOAD_HEADER_LEN];
-  int4store(buf + L_THREAD_ID_OFFSET, (slave_proxy_id ? slave_proxy_id :
-                                       thread_id));
+  int4store(buf + L_THREAD_ID_OFFSET, slave_proxy_id);
   int4store(buf + L_EXEC_TIME_OFFSET, exec_time);
   int4store(buf + L_SKIP_LINES_OFFSET, skip_lines);
   buf[L_TBL_LEN_OFFSET] = (char)table_name_len;
@@ -1276,7 +1274,7 @@ int Load_log_event::copy_log_event(const char *buf, ulong event_len,
   char* buf_end = (char*)buf + event_len;
   uint header_len= old_format ? OLD_HEADER_LEN : LOG_EVENT_HEADER_LEN;
   const char* data_head = buf + header_len;
-  thread_id = uint4korr(data_head + L_THREAD_ID_OFFSET);
+  slave_proxy_id= thread_id= uint4korr(data_head + L_THREAD_ID_OFFSET);
   exec_time = uint4korr(data_head + L_EXEC_TIME_OFFSET);
   skip_lines = uint4korr(data_head + L_SKIP_LINES_OFFSET);
   table_name_len = (uint)data_head[L_TBL_LEN_OFFSET];