return -errno;
bs->read_only = 1;
s->n_chunks = 0;
- s->offsets = s->lengths = s->sectors = s->sectorcounts = 0;
+ s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL;
/* read offset of info blocks */
if(lseek(s->fd,-0x1d8,SEEK_END)<0) {
cid_str_size = sizeof("CID");
}
- if ((p_name = strstr(desc,cid_str)) != 0) {
+ if ((p_name = strstr(desc,cid_str)) != NULL) {
p_name += cid_str_size;
sscanf(p_name,"%x",&cid);
}
tmp_str = strstr(desc,"parentCID");
pstrcpy(tmp_desc, sizeof(tmp_desc), tmp_str);
- if ((p_name = strstr(desc,"CID")) != 0) {
+ if ((p_name = strstr(desc,"CID")) != NULL) {
p_name += sizeof("CID");
snprintf(p_name, sizeof(desc) - (p_name - desc), "%x\n", cid);
pstrcat(desc, sizeof(desc), tmp_desc);
if (read(p_fd, p_desc, DESC_SIZE) != DESC_SIZE)
goto fail;
- if ((p_name = strstr(p_desc,"CID")) != 0) {
+ if ((p_name = strstr(p_desc,"CID")) != NULL) {
p_name += sizeof("CID");
sscanf(p_name,"%x",&p_cid);
}
if (bdrv_pread(s->hd, 0x200, desc, DESC_SIZE) != DESC_SIZE)
return -1;
- if ((p_name = strstr(desc,"parentFileNameHint")) != 0) {
+ if ((p_name = strstr(desc,"parentFileNameHint")) != NULL) {
char *end_name;
struct stat file_buf;
p_name += sizeof("parentFileNameHint") + 1;
- if ((end_name = strchr(p_name,'\"')) == 0)
+ if ((end_name = strchr(p_name,'\"')) == NULL)
return -1;
if ((end_name - p_name) > sizeof (s->hd->backing_file) - 1)
return -1;
static inline void array_init(array_t* array,unsigned int item_size)
{
- array->pointer=0;
+ array->pointer = NULL;
array->size=0;
array->next=0;
array->item_size=item_size;
int increment=count*array->item_size;
array->pointer=qemu_realloc(array->pointer,array->size+increment);
if(!array->pointer)
- return 0;
+ return NULL;
array->size+=increment;
}
memmove(array->pointer+(index+count)*array->item_size,
unsigned int directory_start, const char* filename, int is_dot)
{
int i,j,long_index=s->directory.next;
- direntry_t* entry=0;
- direntry_t* entry_long=0;
+ direntry_t* entry = NULL;
+ direntry_t* entry_long = NULL;
if(is_dot) {
entry=array_get_next(&(s->directory));
int first_cluster = mapping->begin;
int parent_index = mapping->info.dir.parent_mapping_index;
mapping_t* parent_mapping = (mapping_t*)
- (parent_index >= 0 ? array_get(&(s->mapping), parent_index) : 0);
+ (parent_index >= 0 ? array_get(&(s->mapping), parent_index) : NULL);
int first_cluster_of_parent = parent_mapping ? parent_mapping->begin : -1;
DIR* dir=opendir(dirname);
int index=find_mapping_for_cluster_aux(s,cluster_num,0,s->mapping.next);
mapping_t* mapping;
if(index>=s->mapping.next)
- return 0;
+ return NULL;
mapping=array_get(&(s->mapping),index);
if(mapping->begin>cluster_num)
- return 0;
+ return NULL;
assert(mapping->begin<=cluster_num && mapping->end>cluster_num);
return mapping;
}
if (fd < 0) {
fprintf(stderr, "qemu: Can't open `%s': %s (%i)\n",
id, strerror(errno), errno);
- return 0;
+ return NULL;
}
# ifdef CONFIG_BLUEZ
s->hci.acl_send = bt_host_acl;
s->hci.bdaddr_set = bt_host_bdaddr_set;
- qemu_set_fd_handler2(s->fd, bt_host_read_poll, bt_host_read, 0, s);
+ qemu_set_fd_handler2(s->fd, bt_host_read_poll, bt_host_read, NULL, s);
return &s->hci;
}
s->info->evt_recv = vhci_out_hci_packet_event;
s->info->acl_recv = vhci_out_hci_packet_acl;
- qemu_set_fd_handler(s->fd, vhci_read, 0, s);
+ qemu_set_fd_handler(s->fd, vhci_read, NULL, s);
}
unsigned height;
static int color_inited;
- s = new_console(ds, (p == 0) ? TEXT_CONSOLE : TEXT_CONSOLE_FIXED_SIZE);
+ s = new_console(ds, (p == NULL) ? TEXT_CONSOLE : TEXT_CONSOLE_FIXED_SIZE);
if (!s) {
free(chr);
return;
s->y = 0;
width = ds_get_width(s->ds);
height = ds_get_height(s->ds);
- if (p != 0) {
+ if (p != NULL) {
width = strtoul(p, (char **)&p, 10);
if (*p == 'C') {
p++;
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
-
-#include "qemu-common.h"
-#include "console.h"
-#include "sysemu.h"
-
#include <curses.h>
#ifndef _WIN32
#define resize_term resizeterm
#endif
+#include "qemu-common.h"
+#include "console.h"
+#include "sysemu.h"
+
#define FONT_HEIGHT 16
#define FONT_WIDTH 8
CPUWriteMemoryFunc *io_mem_write[IO_MEM_NB_ENTRIES][4];
CPUReadMemoryFunc *io_mem_read[IO_MEM_NB_ENTRIES][4];
void *io_mem_opaque[IO_MEM_NB_ENTRIES];
-char io_mem_used[IO_MEM_NB_ENTRIES];
+static char io_mem_used[IO_MEM_NB_ENTRIES];
static int io_mem_watch;
#endif
mask_byte = (evt - 1) >> 3;
mask = 1 << ((evt - 1) & 3);
if (mask & bt_event_reserved_mask[mask_byte] & ~hci->event_mask[mask_byte])
- return 0;
+ return NULL;
packet = hci->evt_packet(hci->opaque);
packet[0] = evt;
static void bt_hci_lmp_link_teardown(struct bt_hci_s *hci, uint16_t handle)
{
handle &= ~HCI_HANDLE_OFFSET;
- hci->lm.handle[handle].link = 0;
+ hci->lm.handle[handle].link = NULL;
if (bt_hci_role_master(hci, handle)) {
qemu_del_timer(hci->lm.handle[handle].acl_mode_timer);
hci->device.page_scan = 0;
if (hci->device.lmp_name)
qemu_free((void *) hci->device.lmp_name);
- hci->device.lmp_name = 0;
+ hci->device.lmp_name = NULL;
hci->device.class[0] = 0x00;
hci->device.class[1] = 0x00;
hci->device.class[2] = 0x00;
bt_hci_event_status(hci, HCI_SUCCESS);
bt_hci_connection_accept(hci, hci->conn_req_host);
- hci->conn_req_host = 0;
+ hci->conn_req_host = NULL;
break;
case cmd_opcode_pack(OGF_LINK_CTL, OCF_REJECT_CONN_REQ):
bt_hci_connection_reject(hci, hci->conn_req_host,
PARAM(reject_conn_req, reason));
bt_hci_connection_reject_event(hci, &hci->conn_req_host->bd_addr);
- hci->conn_req_host = 0;
+ hci->conn_req_host = NULL;
break;
case cmd_opcode_pack(OGF_LINK_CTL, OCF_AUTH_REQUESTED):
break;
}
s->proto = parameter;
- s->usbdev->handle_control(s->usbdev, SET_PROTOCOL, s->proto, 0, 0, 0);
+ s->usbdev->handle_control(s->usbdev, SET_PROTOCOL, s->proto, 0, 0,
+ NULL);
ret = BT_HS_SUCCESSFUL;
break;
/* We don't need to know about the Idle Rate here really,
* so just pass it on to the device. */
ret = s->usbdev->handle_control(s->usbdev,
- SET_IDLE, data[1], 0, 0, 0) ?
+ SET_IDLE, data[1], 0, 0, NULL) ?
BT_HS_SUCCESSFUL : BT_HS_ERR_INVALID_PARAMETER;
/* XXX: Does this generate a handshake? */
break;
{
struct bt_hid_device_s *hid = opaque;
- hid->control = 0;
+ hid->control = NULL;
bt_hid_connected_update(hid);
}
{
struct bt_hid_device_s *hid = opaque;
- hid->interrupt = 0;
+ hid->interrupt = NULL;
bt_hid_connected_update(hid);
}
static struct l2cap_chan_s *l2cap_channel_open(struct l2cap_instance_s *l2cap,
int psm, int source_cid)
{
- struct l2cap_chan_s *ch = 0;
+ struct l2cap_chan_s *ch = NULL;
struct bt_l2cap_psm_s *psm_info;
int result, status;
int cid = l2cap_cid_new(l2cap);
static void l2cap_channel_close(struct l2cap_instance_s *l2cap,
int cid, int source_cid)
{
- struct l2cap_chan_s *ch = 0;
+ struct l2cap_chan_s *ch = NULL;
/* According to Volume 3, section 6.1.1, pg 1048 of BT Core V2.0, a
* connection in CLOSED state still responds with a L2CAP_DisconnectRsp
return;
}
- l2cap->cid[cid] = 0;
+ l2cap->cid[cid] = NULL;
ch->params.close(ch->params.opaque);
qemu_free(ch);
static void l2cap_channel_config_null(struct l2cap_instance_s *l2cap,
struct l2cap_chan_s *ch)
{
- l2cap_configuration_request(l2cap, ch->remote_cid, 0, 0, 0);
+ l2cap_configuration_request(l2cap, ch->remote_cid, 0, NULL, 0);
ch->config_req_id = l2cap->last_id;
ch->config &= ~L2CAP_CFG_INIT;
}
&sdp_service_sdp_s,
&sdp_service_hid_s,
&sdp_service_pnp_s,
- 0,
+ NULL,
};
sdp->channel = params;
#define MPC8544_PCI_IO 0xE1000000
#define MPC8544_PCI_IOLEN 0x10000
+#ifdef HAVE_FDT
static int mpc8544_copy_soc_cell(void *fdt, const char *node, const char *prop)
{
uint32_t cell;
out:
return ret;
}
+#endif
static void *mpc8544_load_device_tree(void *addr,
uint32_t ramsize,
{
struct USBBtState *s = (struct USBBtState *) dev->opaque;
- s->hci->opaque = 0;
- s->hci->evt_recv = 0;
- s->hci->acl_recv = 0;
+ s->hci->opaque = NULL;
+ s->hci->evt_recv = NULL;
+ s->hci->acl_recv = NULL;
qemu_free(s);
}
#ifdef VERBOSE
# define GUEST_OS_BASE 0x5001
static const char *vmsvga_guest_id[] = {
- [0x00 ... 0x15] = "an unknown OS",
[0x00] = "Dos",
[0x01] = "Windows 3.1",
[0x02] = "Windows 95",
[0x06] = "Windows 2000",
[0x07] = "Linux",
[0x08] = "OS/2",
+ [0x09] = "an unknown OS",
[0x0a] = "BSD",
[0x0b] = "Whistler",
+ [0x0c] = "an unknown OS",
+ [0x0d] = "an unknown OS",
+ [0x0e] = "an unknown OS",
+ [0x0f] = "an unknown OS",
+ [0x10] = "an unknown OS",
+ [0x11] = "an unknown OS",
+ [0x12] = "an unknown OS",
+ [0x13] = "an unknown OS",
+ [0x14] = "an unknown OS",
[0x15] = "Windows 2003",
};
#endif
for (i = 0; i < IN_PORT_N; i ++)
if (s->adc_voice[i]) {
AUD_close_in(&s->card, s->adc_voice[i]);
- s->adc_voice[i] = 0;
+ s->adc_voice[i] = NULL;
}
for (i = 0; i < OUT_PORT_N; i ++)
if (s->dac_voice[i]) {
AUD_close_out(&s->card, s->dac_voice[i]);
- s->dac_voice[i] = 0;
+ s->dac_voice[i] = NULL;
}
if (!s->enable)
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
+#include <dirent.h>
#include "hw/hw.h"
#include "hw/usb.h"
#include "hw/pcmcia.h"
#include "audio/audio.h"
#include "disas.h"
#include "balloon.h"
-#include <dirent.h>
#include "qemu-timer.h"
#include "migration.h"
#include "kvm.h"
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
-#include "qemu-common.h"
-#include "net.h"
-#include "monitor.h"
-#include "sysemu.h"
-#include "qemu-timer.h"
-#include "qemu-char.h"
-#include "audio/audio.h"
-
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#endif
#endif
-#include "qemu_socket.h"
-
-#if defined(CONFIG_SLIRP)
-#include "libslirp.h"
-#endif
-
#if defined(__OpenBSD__)
#include <util.h>
#endif
#define memalign(align, size) malloc(size)
#endif
+#include "qemu-common.h"
+#include "net.h"
+#include "monitor.h"
+#include "sysemu.h"
+#include "qemu-timer.h"
+#include "qemu-char.h"
+#include "audio/audio.h"
+#include "qemu_socket.h"
+
+#if defined(CONFIG_SLIRP)
+#include "libslirp.h"
+#endif
+
+
static VLANState *first_vlan;
/***********************************************************/
char filename[1024];
/* erase all the files in the directory */
- if ((d = opendir(dir_name)) != 0) {
+ if ((d = opendir(dir_name)) != NULL) {
for(;;) {
de = readdir(d);
if (!de)
struct VMChannel {
CharDriverState *hd;
int port;
-} *vmchannels;
+};
static int vmchannel_can_read(void *opaque)
{
#include <sys/statvfs.h>
#endif
-#include "qemu-common.h"
-#include "sysemu.h"
-
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <malloc.h>
#endif
+#include "qemu-common.h"
+#include "sysemu.h"
#include "qemu_socket.h"
#if defined(_WIN32)
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
-#include "qemu-common.h"
-#include "hw/hw.h"
-#include "net.h"
-#include "monitor.h"
-#include "sysemu.h"
-#include "qemu-timer.h"
-#include "qemu-char.h"
-#include "block.h"
-#include "audio/audio.h"
-#include "migration.h"
-#include "qemu_socket.h"
-
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#define memalign(align, size) malloc(size)
#endif
+#include "qemu-common.h"
+#include "hw/hw.h"
+#include "net.h"
+#include "monitor.h"
+#include "sysemu.h"
+#include "qemu-timer.h"
+#include "qemu-char.h"
+#include "block.h"
+#include "audio/audio.h"
+#include "migration.h"
+#include "qemu_socket.h"
+
/* point to the block driver where the snapshots are managed */
static BlockDriverState *bs_snapshots;
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
-#include "qemu-common.h"
-#include "console.h"
-#include "sysemu.h"
-#include "x_keymap.h"
-
#include <SDL.h>
#include <SDL/SDL_syswm.h>
#include <signal.h>
#endif
+#include "qemu-common.h"
+#include "console.h"
+#include "sysemu.h"
+#include "x_keymap.h"
+
static DisplayChangeListener *dcl;
static SDL_Surface *real_screen;
static SDL_Surface *guest_screen = NULL;
}
void
-if_init()
+if_init(void)
{
if_fastq.ifq_next = if_fastq.ifq_prev = &if_fastq;
if_batchq.ifq_next = if_batchq.ifq_prev = &if_batchq;
* it'll temporarily get downgraded to the batchq)
*/
void
-if_output(so, ifm)
- struct socket *so;
- struct mbuf *ifm;
+if_output(struct socket *so, struct mbuf *ifm)
{
struct mbuf *ifq;
int on_fastq = 1;
* Process a received ICMP message.
*/
void
-icmp_input(m, hlen)
- struct mbuf *m;
- int hlen;
+icmp_input(struct mbuf *m, int hlen)
{
register struct icmp *icp;
register struct ip *ip=mtod(m, struct ip *);
* Reflect the ip packet back to the source
*/
void
-icmp_reflect(m)
- struct mbuf *m;
+icmp_reflect(struct mbuf *m)
{
register struct ip *ip = mtod(m, struct ip *);
int hlen = ip->ip_hl << 2;
* All protocols not implemented in kernel go to raw IP protocol handler.
*/
void
-ip_init()
+ip_init(void)
{
ipq.ip_link.next = ipq.ip_link.prev = &ipq.ip_link;
ip_id = tt.tv_sec & 0xffff;
* try to reassemble. Process options. Pass to next level.
*/
void
-ip_input(m)
- struct mbuf *m;
+ip_input(struct mbuf *m)
{
register struct ip *ip;
int hlen;
if (ip->ip_tos & 1 || ip->ip_off) {
STAT(ipstat.ips_fragments++);
ip = ip_reass(ip, fp);
- if (ip == 0)
+ if (ip == NULL)
return;
STAT(ipstat.ips_reassembled++);
m = dtom(ip);
/*
* If first fragment to arrive, create a reassembly queue.
*/
- if (fp == 0) {
+ if (fp == NULL) {
struct mbuf *t;
if ((t = m_get()) == NULL) goto dropfrag;
fp = mtod(t, struct ipq *);
for (q = fp->frag_link.next; q != (struct ipasfrag*)&fp->frag_link;
q = q->ipf_next) {
if (q->ipf_off != next)
- return (0);
+ return NULL;
next += q->ipf_len;
}
if (((struct ipasfrag *)(q->ipf_prev))->ipf_tos & 1)
- return (0);
+ return NULL;
/*
* Reassembly is complete; concatenate fragments.
dropfrag:
STAT(ipstat.ips_fragdropped++);
m_freem(m);
- return (0);
+ return NULL;
}
/*
* queue, discard it.
*/
void
-ip_slowtimo()
+ip_slowtimo(void)
{
struct qlink *l;
l = ipq.ip_link.next;
- if (l == 0)
+ if (l == NULL)
return;
while (l != &ipq.ip_link) {
* (XXX) should be deleted; last arg currently ignored.
*/
void
-ip_stripoptions(m, mopt)
- register struct mbuf *m;
- struct mbuf *mopt;
+ip_stripoptions(register struct mbuf *m, struct mbuf *mopt)
{
register int i;
struct ip *ip = mtod(m, struct ip *);
* The mbuf opt, if present, will not be freed.
*/
int
-ip_output(so, m0)
- struct socket *so;
- struct mbuf *m0;
+ip_output(struct socket *so, struct mbuf *m0)
{
register struct ip *ip;
register struct mbuf *m = m0;
for (off = hlen + len; off < (u_int16_t)ip->ip_len; off += len) {
register struct ip *mhip;
m = m_get();
- if (m == 0) {
+ if (m == NULL) {
error = -1;
STAT(ipstat.ips_odropped++);
goto sendorfree;
sendorfree:
for (m = m0; m; m = m0) {
m0 = m->m_nextpkt;
- m->m_nextpkt = 0;
+ m->m_nextpkt = NULL;
if (error == 0)
if_output(so, m);
else
extern "C" {
#endif
-void slirp_init(int restrict, char *special_ip);
+void slirp_init(int restricted, char *special_ip);
void slirp_select_fill(int *pnfds,
fd_set *readfds, fd_set *writefds, fd_set *xfds);
#define SLIRP_MSIZE (IF_MTU + IF_MAXLINKHDR + sizeof(struct m_hdr ) + 6)
void
-m_init()
+m_init(void)
{
m_freelist.m_next = m_freelist.m_prev = &m_freelist;
m_usedlist.m_next = m_usedlist.m_prev = &m_usedlist;
* which tells m_free to actually free() it
*/
struct mbuf *
-m_get()
+m_get(void)
{
register struct mbuf *m;
int flags = 0;
m->m_size = SLIRP_MSIZE - sizeof(struct m_hdr);
m->m_data = m->m_dat;
m->m_len = 0;
- m->m_nextpkt = 0;
- m->m_prevpkt = 0;
+ m->m_nextpkt = NULL;
+ m->m_prevpkt = NULL;
end_error:
DEBUG_ARG("m = %lx", (long )m);
return m;
}
void
-m_free(m)
- struct mbuf *m;
+m_free(struct mbuf *m)
{
DEBUG_CALL("m_free");
* an M_EXT data segment
*/
void
-m_cat(m, n)
- register struct mbuf *m, *n;
+m_cat(struct mbuf *m, struct mbuf *n)
{
/*
* If there's no room, realloc
/* make m size bytes large */
void
-m_inc(m, size)
- struct mbuf *m;
- int size;
+m_inc(struct mbuf *m, int size)
{
int datasize;
void
-m_adj(m, len)
- struct mbuf *m;
- int len;
+m_adj(struct mbuf *m, int len)
{
if (m == NULL)
return;
* Copy len bytes from m, starting off bytes into n
*/
int
-m_copy(n, m, off, len)
- struct mbuf *n, *m;
- int off, len;
+m_copy(struct mbuf *n, struct mbuf *m, int off, int len)
{
if (len > M_FREEROOM(n))
return -1;
* Fortunately, it's not used often
*/
struct mbuf *
-dtom(dat)
- void *dat;
+dtom(void *dat)
{
struct mbuf *m;
* Get our IP address and put it in our_addr
*/
void
-getouraddr()
+getouraddr(void)
{
char buff[256];
struct hostent *he = NULL;
};
inline void
-insque(a, b)
- void *a, *b;
+insque(void *a, void *b)
{
register struct quehead *element = (struct quehead *) a;
register struct quehead *head = (struct quehead *) b;
}
inline void
-remque(a)
- void *a;
+remque(void *a)
{
register struct quehead *element = (struct quehead *) a;
((struct quehead *)(element->qh_link))->qh_rlink = element->qh_rlink;
int
-add_exec(ex_ptr, do_pty, exec, addr, port)
- struct ex_list **ex_ptr;
- int do_pty;
- char *exec;
- int addr;
- int port;
+add_exec(struct ex_list **ex_ptr, int do_pty, char *exec, int addr, int port)
{
struct ex_list *tmp_ptr;
argv[i++] = strdup(curarg);
} while (c);
- argv[i] = 0;
+ argv[i] = NULL;
execvp(argv[0], (char **)argv);
/* Ooops, failed, let's tell the user why */
fd_nonblock(so->s);
/* Append the telnet options now */
- if (so->so_m != 0 && do_pty == 1) {
+ if (so->so_m != NULL && do_pty == 1) {
sbappend(so, so->so_m);
- so->so_m = 0;
+ so->so_m = NULL;
}
return 1;
#endif
void
-u_sleep(usec)
- int usec;
+u_sleep(int usec)
{
struct timeval t;
fd_set fdset;
*/
void
-fd_nonblock(fd)
- int fd;
+fd_nonblock(int fd)
{
#ifdef FIONBIO
int opt = 1;
}
void
-fd_block(fd)
- int fd;
+fd_block(int fd)
{
#ifdef FIONBIO
int opt = 0;
*/
void
-sbfree(sb)
- struct sbuf *sb;
+sbfree(struct sbuf *sb)
{
free(sb->sb_data);
}
void
-sbdrop(sb, num)
- struct sbuf *sb;
- int num;
+sbdrop(struct sbuf *sb, int num)
{
/*
* We can only drop how much we have
}
void
-sbreserve(sb, size)
- struct sbuf *sb;
- int size;
+sbreserve(struct sbuf *sb, int size)
{
if (sb->sb_data) {
/* Already alloced, realloc if necessary */
* (the socket is non-blocking, so we won't hang)
*/
void
-sbappend(so, m)
- struct socket *so;
- struct mbuf *m;
+sbappend(struct socket *so, struct mbuf *m)
{
int ret = 0;
* done in sbdrop when the data is acked
*/
void
-sbcopy(sb, off, len, to)
- struct sbuf *sb;
- int off;
- int len;
- char *to;
+sbcopy(struct sbuf *sb, int off, int len, char *to)
{
char *from;
const char *slirp_special_ip = CTL_SPECIAL;
int slirp_restrict;
-int do_slowtimo;
+static int do_slowtimo;
int link_up;
struct timeval tt;
FILE *lfd;
static void slirp_state_save(QEMUFile *f, void *opaque);
static int slirp_state_load(QEMUFile *f, void *opaque, int version_id);
-void slirp_init(int restrict, char *special_ip)
+void slirp_init(int restricted, char *special_ip)
{
// debug_init("/tmp/slirp.log", DEBUG_DEFAULT);
#endif
link_up = 1;
- slirp_restrict = restrict;
+ slirp_restrict = restricted;
if_init();
ip_init();
#else
static void updtime(void)
{
- gettimeofday(&tt, 0);
+ gettimeofday(&tt, NULL);
curtime = (u_int)tt.tv_sec * (u_int)1000;
curtime += (u_int)tt.tv_usec / (u_int)1000;
#endif
struct socket *
-solookup(head, laddr, lport, faddr, fport)
- struct socket *head;
- struct in_addr laddr;
- u_int lport;
- struct in_addr faddr;
- u_int fport;
+solookup(struct socket *head, struct in_addr laddr, u_int lport,
+ struct in_addr faddr, u_int fport)
{
struct socket *so;
* insque() it into the correct linked-list
*/
struct socket *
-socreate()
+socreate(void)
{
struct socket *so;
* remque and free a socket, clobber cache
*/
void
-sofree(so)
- struct socket *so;
+sofree(struct socket *so)
{
if (so->so_emu==EMU_RSH && so->extra) {
sofree(so->extra);
* a read() of 0 (or less) means it's disconnected
*/
int
-soread(so)
- struct socket *so;
+soread(struct socket *so)
{
int n, nn;
struct sbuf *sb = &so->so_snd;
* in the send buffer is sent as urgent data
*/
void
-sorecvoob(so)
- struct socket *so;
+sorecvoob(struct socket *so)
{
struct tcpcb *tp = sototcpcb(so);
* There's a lot duplicated code here, but...
*/
int
-sosendoob(so)
- struct socket *so;
+sosendoob(struct socket *so)
{
struct sbuf *sb = &so->so_rcv;
char buff[2048]; /* XXX Shouldn't be sending more oob data than this */
* updating all sbuf field as necessary
*/
int
-sowrite(so)
- struct socket *so;
+sowrite(struct socket *so)
{
int n,nn;
struct sbuf *sb = &so->so_rcv;
* recvfrom() a UDP socket
*/
void
-sorecvfrom(so)
- struct socket *so;
+sorecvfrom(struct socket *so)
{
struct sockaddr_in addr;
socklen_t addrlen = sizeof(struct sockaddr_in);
icmp_error(so->so_m, ICMP_UNREACH,code, 0,strerror(errno));
} else {
icmp_reflect(so->so_m);
- so->so_m = 0; /* Don't m_free() it again! */
+ so->so_m = NULL; /* Don't m_free() it again! */
}
/* No need for this socket anymore, udp_detach it */
udp_detach(so);
* sendto() a socket
*/
int
-sosendto(so, m)
- struct socket *so;
- struct mbuf *m;
+sosendto(struct socket *so, struct mbuf *m)
{
int ret;
struct sockaddr_in addr;
* XXX This should really be tcp_listen
*/
struct socket *
-solisten(port, laddr, lport, flags)
- u_int port;
- u_int32_t laddr;
- u_int lport;
- int flags;
+solisten(u_int port, u_int32_t laddr, u_int lport, int flags)
{
struct sockaddr_in addr;
struct socket *so;
* times each when only 1 was needed
*/
void
-soisfconnecting(so)
- register struct socket *so;
+soisfconnecting(struct socket *so)
{
so->so_state &= ~(SS_NOFDREF|SS_ISFCONNECTED|SS_FCANTRCVMORE|
SS_FCANTSENDMORE|SS_FWDRAIN);
}
void
-soisfconnected(so)
- register struct socket *so;
+soisfconnected(struct socket *so)
{
so->so_state &= ~(SS_ISFCONNECTING|SS_FWDRAIN|SS_NOFDREF);
so->so_state |= SS_ISFCONNECTED; /* Clobber other states */
}
void
-soisfdisconnected(so)
- struct socket *so;
+soisfdisconnected(struct socket *so)
{
/* so->so_state &= ~(SS_ISFCONNECTING|SS_ISFCONNECTED); */
/* close(so->s); */
* Set CANTSENDMORE once all data has been write()n
*/
void
-sofwdrain(so)
- struct socket *so;
+sofwdrain(struct socket *so)
{
if (so->so_rcv.sb_cc)
so->so_state |= SS_FWDRAIN;
int flags;
/*
- * Call with ti==0 after become established to
+ * Call with ti==NULL after become established to
* force pre-ESTABLISHED data up to user socket.
*/
- if (ti == 0)
+ if (ti == NULL)
goto present;
/*
* protocol specification dated September, 1981 very closely.
*/
void
-tcp_input(m, iphlen, inso)
- register struct mbuf *m;
- int iphlen;
- struct socket *inso;
+tcp_input(struct mbuf *m, int iphlen, struct socket *inso)
{
struct ip save_ip, *ip;
register struct tcpiphdr *ti;
caddr_t optp = NULL;
int optlen = 0;
int len, tlen, off;
- register struct tcpcb *tp = 0;
+ register struct tcpcb *tp = NULL;
register int tiflags;
- struct socket *so = 0;
+ struct socket *so = NULL;
int todrop, acked, ourfinisacked, needoutput = 0;
/* int dropsocket = 0; */
int iss = 0;
/* Re-set a few variables */
tp = sototcpcb(so);
m = so->so_m;
- so->so_m = 0;
+ so->so_m = NULL;
ti = so->so_ti;
tiwin = ti->ti_win;
tiflags = ti->ti_flags;
* Checksum extended TCP header and data.
*/
tlen = ((struct ip *)ti)->ip_len;
- tcpiphdr2qlink(ti)->next = tcpiphdr2qlink(ti)->prev = 0;
- memset(&ti->ti_i.ih_mbuf, 0 , sizeof(struct mbuf_ptr));
+ tcpiphdr2qlink(ti)->next = tcpiphdr2qlink(ti)->prev = NULL;
+ memset(&ti->ti_i.ih_mbuf, 0 , sizeof(struct mbuf_ptr));
ti->ti_x1 = 0;
ti->ti_len = htons((u_int16_t)tlen);
len = sizeof(struct ip ) + tlen;
* the only flag set, then create a session, mark it
* as if it was LISTENING, and continue...
*/
- if (so == 0) {
+ if (so == NULL) {
if ((tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) != TH_SYN)
goto dropwithreset;
tp = sototcpcb(so);
/* XXX Should never fail */
- if (tp == 0)
+ if (tp == NULL)
goto dropwithreset;
if (tp->t_state == TCPS_CLOSED)
goto drop;
*/
int
-tcp_mss(tp, offer)
- register struct tcpcb *tp;
- u_int offer;
+tcp_mss(struct tcpcb *tp, u_int offer)
{
struct socket *so = tp->t_socket;
int mss;
* Tcp output routine: figure out what should be sent and send it.
*/
int
-tcp_output(tp)
- register struct tcpcb *tp;
+tcp_output(struct tcpcb *tp)
{
register struct socket *so = tp->t_socket;
register long len, win;
}
void
-tcp_setpersist(tp)
- register struct tcpcb *tp;
+tcp_setpersist(struct tcpcb *tp)
{
int t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1;
* Tcp initialization
*/
void
-tcp_init()
+tcp_init(void)
{
tcp_iss = 1; /* wrong */
tcb.so_next = tcb.so_prev = &tcb;
*/
/* struct tcpiphdr * */
void
-tcp_template(tp)
- struct tcpcb *tp;
+tcp_template(struct tcpcb *tp)
{
struct socket *so = tp->t_socket;
register struct tcpiphdr *n = &tp->t_template;
* segment are as specified by the parameters.
*/
void
-tcp_respond(tp, ti, m, ack, seq, flags)
- struct tcpcb *tp;
- register struct tcpiphdr *ti;
- register struct mbuf *m;
- tcp_seq ack, seq;
- int flags;
+tcp_respond(struct tcpcb *tp, struct tcpiphdr *ti, struct mbuf *m,
+ tcp_seq ack, tcp_seq seq, int flags)
{
register int tlen;
int win = 0;
if (tp)
win = sbspace(&tp->t_socket->so_rcv);
- if (m == 0) {
+ if (m == NULL) {
if ((m = m_get()) == NULL)
return;
#ifdef TCP_COMPAT_42
tlen += sizeof (struct tcpiphdr);
m->m_len = tlen;
- ti->ti_mbuf = 0;
+ ti->ti_mbuf = NULL;
ti->ti_x1 = 0;
ti->ti_seq = htonl(seq);
ti->ti_ack = htonl(ack);
* protocol control block.
*/
struct tcpcb *
-tcp_newtcpcb(so)
- struct socket *so;
+tcp_newtcpcb(struct socket *so)
{
register struct tcpcb *tp;
* wake up any sleepers
*/
struct tcpcb *
-tcp_close(tp)
- register struct tcpcb *tp;
+tcp_close(struct tcpcb *tp)
{
register struct tcpiphdr *t;
struct socket *so = tp->t_socket;
*/
/* free(tp, M_PCB); */
free(tp);
- so->so_tcpcb = 0;
+ so->so_tcpcb = NULL;
soisfdisconnected(so);
/* clobber input socket cache if we're closing the cached connection */
if (so == tcp_last_so)
* We can let the user exit from the close as soon as the FIN is acked.
*/
void
-tcp_sockclosed(tp)
- struct tcpcb *tp;
+tcp_sockclosed(struct tcpcb *tp)
{
DEBUG_CALL("tcp_sockclosed");
* nonblocking. Connect returns after the SYN is sent, and does
* not wait for ACK+SYN.
*/
-int tcp_fconnect(so)
- struct socket *so;
+int tcp_fconnect(struct socket *so)
{
int ret=0;
* here and SYN the local-host.
*/
void
-tcp_connect(inso)
- struct socket *inso;
+tcp_connect(struct socket *inso)
{
struct socket *so;
struct sockaddr_in addr;
* Attach a TCPCB to a socket.
*/
int
-tcp_attach(so)
- struct socket *so;
+tcp_attach(struct socket *so)
{
if ((so->so_tcpcb = tcp_newtcpcb(so)) == NULL)
return -1;
#ifdef CONFIG_QEMU
static
#endif
-struct emu_t *tcpemu = 0;
+struct emu_t *tcpemu = NULL;
/*
* Return TOS according to the above table
*/
u_int8_t
-tcp_tos(so)
- struct socket *so;
+tcp_tos(struct socket *so)
{
int i = 0;
struct emu_t *emup;
* NOTE: if you return 0 you MUST m_free() the mbuf!
*/
int
-tcp_emu(so, m)
- struct socket *so;
- struct mbuf *m;
+tcp_emu(struct socket *so, struct mbuf *m)
{
u_int n1, n2, n3, n4, n5, n6;
char buff[257];
}
#endif
case EMU_FTP: /* ftp */
- *(m->m_data+m->m_len) = 0; /* NULL terminate for strstr */
+ *(m->m_data+m->m_len) = 0; /* NUL terminate for strstr */
if ((bptr = (char *)strstr(m->m_data, "ORT")) != NULL) {
/*
* Need to emulate the PORT command
* return 2 if this is a command-line connection
*/
int
-tcp_ctl(so)
- struct socket *so;
+tcp_ctl(struct socket *so)
{
struct sbuf *sb = &so->so_snd;
int command;
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
-#include "hw/hw.h"
-#include "hw/boards.h"
-#include "hw/usb.h"
-#include "hw/pcmcia.h"
-#include "hw/pc.h"
-#include "hw/audiodev.h"
-#include "hw/isa.h"
-#include "hw/baum.h"
-#include "hw/bt.h"
-#include "net.h"
-#include "monitor.h"
-#include "console.h"
-#include "sysemu.h"
-#include "gdbstub.h"
-#include "qemu-timer.h"
-#include "qemu-char.h"
-#include "cache-utils.h"
-#include "block.h"
-#include "audio/audio.h"
-#include "migration.h"
-#include "kvm.h"
-#include "balloon.h"
-
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#endif
#endif
-#include "qemu_socket.h"
-
-#if defined(CONFIG_SLIRP)
-#include "libslirp.h"
-#endif
-
#if defined(__OpenBSD__)
#include <util.h>
#endif
#define main qemu_main
#endif /* CONFIG_COCOA */
+#include "hw/hw.h"
+#include "hw/boards.h"
+#include "hw/usb.h"
+#include "hw/pcmcia.h"
+#include "hw/pc.h"
+#include "hw/audiodev.h"
+#include "hw/isa.h"
+#include "hw/baum.h"
+#include "hw/bt.h"
+#include "net.h"
+#include "monitor.h"
+#include "console.h"
+#include "sysemu.h"
+#include "gdbstub.h"
+#include "qemu-timer.h"
+#include "qemu-char.h"
+#include "cache-utils.h"
+#include "block.h"
+#include "audio/audio.h"
+#include "migration.h"
+#include "kvm.h"
+#include "balloon.h"
+
#include "disas.h"
#include "exec-all.h"
+#include "qemu_socket.h"
+
+#if defined(CONFIG_SLIRP)
+#include "libslirp.h"
+#endif
+
//#define DEBUG_UNUSED_IOPORT
//#define DEBUG_IOPORT
//#define DEBUG_NET
projects / qemu.git / commitdiff