Archipelago » qemu

        return -errno;

    bs->read_only = 1;

    s->n_chunks = 0;

    /* read offset of info blocks */

    if(lseek(s->fd,-0x1d8,SEEK_END)<0) {

        cid_str_size = sizeof("CID");

    }

        p_name += cid_str_size;

        sscanf(p_name,"%x",&cid);

    }

    tmp_str = strstr(desc,"parentCID");

    pstrcpy(tmp_desc, sizeof(tmp_desc), tmp_str);

        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;

        p_name += sizeof("CID");

        sscanf(p_name,"%x",&p_cid);

    }

    if (bdrv_pread(s->hd, 0x200, desc, DESC_SIZE) != DESC_SIZE)

        return -1;

        char *end_name;

        struct stat file_buf;

        p_name += sizeof("parentFileNameHint") + 1;

            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->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)

	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;

    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*)

    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)

    mapping=array_get(&(s->mapping),index);

    if(mapping->begin>cluster_num)

    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);

    }

# ifdef CONFIG_BLUEZ

    s->hci.acl_send = bt_host_acl;

    s->hci.bdaddr_set = bt_host_bdaddr_set;

    return &s->hci;

}

    s->info->evt_recv = vhci_out_hci_packet_event;

    s->info->acl_recv = vhci_out_hci_packet_acl;

}

    unsigned height;

    static int color_inited;

    if (!s) {

        free(chr);

        return;

    s->y = 0;

    width = ds_get_width(s->ds);

    height = ds_get_height(s->ds);

        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 <curses.h>

#ifndef _WIN32

#define resize_term resizeterm

#endif

#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];

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])

    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;

    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.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);

        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);

        break;

    case cmd_opcode_pack(OGF_LINK_CTL, OCF_AUTH_REQUESTED):

            break;

        }

        s->proto = parameter;

        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,

                BT_HS_SUCCESSFUL : BT_HS_ERR_INVALID_PARAMETER;

        /* XXX: Does this generate a handshake? */

        break;

{

    struct bt_hid_device_s *hid = opaque;

    bt_hid_connected_update(hid);

}

{

    struct bt_hid_device_s *hid = opaque;

    bt_hid_connected_update(hid);

}

static struct l2cap_chan_s *l2cap_channel_open(struct l2cap_instance_s *l2cap,

                int psm, int source_cid)

{

    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)

{

    /* 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;

        }

        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)

{

    ch->config_req_id = l2cap->last_id;

    ch->config &= ~L2CAP_CFG_INIT;

}

        &sdp_service_sdp_s,

        &sdp_service_hid_s,

        &sdp_service_pnp_s,

    };

    sdp->channel = params;

#define MPC8544_PCI_IO             0xE1000000

#define MPC8544_PCI_IOLEN          0x10000

static int mpc8544_copy_soc_cell(void *fdt, const char *node, const char *prop)

{

    uint32_t cell;

out:

    return ret;

}

static void *mpc8544_load_device_tree(void *addr,

                                     uint32_t ramsize,

{

    struct USBBtState *s = (struct USBBtState *) dev->opaque;

    qemu_free(s);

}

#ifdef VERBOSE

# define GUEST_OS_BASE		0x5001

static const char *vmsvga_guest_id[] = {

    [0x00] = "Dos",

    [0x01] = "Windows 3.1",

    [0x02] = "Windows 95",

    [0x06] = "Windows 2000",

    [0x07] = "Linux",

    [0x08] = "OS/2",

    [0x0a] = "BSD",

    [0x0b] = "Whistler",

    [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]);

        }

    for (i = 0; i < OUT_PORT_N; i ++)

        if (s->dac_voice[i]) {

            AUD_close_out(&s->card, s->dac_voice[i]);

        }

    if (!s->enable)

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include "hw/hw.h"

#include "hw/usb.h"

#include "hw/pcmcia.h"

#include "audio/audio.h"

#include "disas.h"

#include "balloon.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 <unistd.h>

#include <fcntl.h>

#include <signal.h>

#endif

#endif

#if defined(__OpenBSD__)

#include <util.h>

#endif

#define memalign(align, size) malloc(size)

#endif

static VLANState *first_vlan;

/***********************************************************/

    char filename[1024];

    /* erase all the files in the directory */

        for(;;) {

            de = readdir(d);

            if (!de)

struct VMChannel {

    CharDriverState *hd;

    int port;

static int vmchannel_can_read(void *opaque)

{

#include <sys/statvfs.h>

#endif

#ifdef _WIN32

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

#include <malloc.h>

#endif

#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 <unistd.h>

#include <fcntl.h>

#include <signal.h>

#define memalign(align, size) malloc(size)

#endif

/* 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 <SDL.h>

#include <SDL/SDL_syswm.h>

#include <signal.h>

#endif

static DisplayChangeListener *dcl;

static SDL_Surface *real_screen;

static SDL_Surface *guest_screen = NULL;

}

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

{

	struct mbuf *ifq;

	int on_fastq = 1;

 * Process a received ICMP message.

 */

void

{

  register struct icmp *icp;

  register struct ip *ip=mtod(m, struct ip *);

 * Reflect the ip packet back to the source

 */

void

{

  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

{

	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

{

	register struct ip *ip;

	int hlen;

		if (ip->ip_tos & 1 || ip->ip_off) {

			STAT(ipstat.ips_fragments++);

			ip = ip_reass(ip, fp);

				return;

			STAT(ipstat.ips_reassembled++);

			m = dtom(ip);

	/*

	 * If first fragment to arrive, create a reassembly queue.

	 */

	  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)

		next += q->ipf_len;

	}

	if (((struct ipasfrag *)(q->ipf_prev))->ipf_tos & 1)

	/*

	 * Reassembly is complete; concatenate fragments.

dropfrag:

	STAT(ipstat.ips_fragdropped++);

	m_freem(m);

}

/*

 * queue, discard it.

 */

void

{

    struct qlink *l;

    l = ipq.ip_link.next;

	   return;

	while (l != &ipq.ip_link) {

 * (XXX) should be deleted; last arg currently ignored.

 */

void

{

	register int i;

	struct ip *ip = mtod(m, struct ip *);

 * The mbuf opt, if present, will not be freed.

 */

int

{

	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();

	    error = -1;

	    STAT(ipstat.ips_odropped++);

	    goto sendorfree;

sendorfree:

	for (m = m0; m; m = m0) {

		m0 = m->m_nextpkt;

		if (error == 0)

			if_output(so, m);

		else

extern "C" {

#endif

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_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 *

{

	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;

end_error:

	DEBUG_ARG("m = %lx", (long )m);

	return m;

}

void

{

  DEBUG_CALL("m_free");

 * an M_EXT data segment

 */

void

{

	/*

	 * If there's no room, realloc

/* make m size bytes large */

void

{

	int datasize;

void

{

	if (m == NULL)

		return;

 * Copy len bytes from m, starting off bytes into n

 */

int

{

	if (len > M_FREEROOM(n))

		return -1;

 * Fortunately, it's not used often

 */

struct mbuf *

{

	struct mbuf *m;

 * Get our IP address and put it in our_addr

 */

void

{

	char buff[256];

	struct hostent *he = NULL;

};

inline void

{

	register struct quehead *element = (struct quehead *) a;

	register struct quehead *head = (struct quehead *) b;

}

inline void

{

  register struct quehead *element = (struct quehead *) a;

  ((struct quehead *)(element->qh_link))->qh_rlink = element->qh_rlink;

int

{

	struct ex_list *tmp_ptr;

			argv[i++] = strdup(curarg);

		   } while (c);

		execvp(argv[0], (char **)argv);

		/* Ooops, failed, let's tell the user why */

		fd_nonblock(so->s);

		/* Append the telnet options now */

			sbappend(so, so->so_m);

		}

		return 1;

#endif

void

{

	struct timeval t;

	fd_set fdset;

 */

void

{

#ifdef FIONBIO

	int opt = 1;

}

void

{

#ifdef FIONBIO

	int opt = 0;

 */

void

{

	free(sb->sb_data);

}

void

{

	/*

	 * We can only drop how much we have

}

void

{

	if (sb->sb_data) {

		/* Already alloced, realloc if necessary */

 * (the socket is non-blocking, so we won't hang)

 */

void

{

	int ret = 0;

 * done in sbdrop when the data is acked

 */

void

{

	char *from;

const char *slirp_special_ip = CTL_SPECIAL;

int slirp_restrict;

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);

{

    //    debug_init("/tmp/slirp.log", DEBUG_DEFAULT);

#endif

    link_up = 1;

    if_init();

    ip_init();

#else

static void updtime(void)

{

	curtime = (u_int)tt.tv_sec * (u_int)1000;

	curtime += (u_int)tt.tv_usec / (u_int)1000;

#endif

struct socket *

{

	struct socket *so;

 * insque() it into the correct linked-list

 */

struct socket *

{

  struct socket *so;

 * remque and free a socket, clobber cache

 */

void

{

  if (so->so_emu==EMU_RSH && so->extra) {

	sofree(so->extra);

 * a read() of 0 (or less) means it's disconnected

 */

int

{

	int n, nn;

	struct sbuf *sb = &so->so_snd;

 * in the send buffer is sent as urgent data

 */

void

{

	struct tcpcb *tp = sototcpcb(so);

 * There's a lot duplicated code here, but...

 */

int

{

	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

{

	int  n,nn;

	struct sbuf *sb = &so->so_rcv;

 * recvfrom() a UDP socket

 */

void

{

	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);

	  }

	  /* No need for this socket anymore, udp_detach it */

	  udp_detach(so);

 * sendto() a socket

 */

int

{

	int ret;

	struct sockaddr_in addr;

 * XXX This should really be tcp_listen

 */

struct socket *

{

	struct sockaddr_in addr;

	struct socket *so;

 * times each when only 1 was needed

 */

void

{

	so->so_state &= ~(SS_NOFDREF|SS_ISFCONNECTED|SS_FCANTRCVMORE|

			  SS_FCANTSENDMORE|SS_FWDRAIN);

}

void

{

	so->so_state &= ~(SS_ISFCONNECTING|SS_FWDRAIN|SS_NOFDREF);

	so->so_state |= SS_ISFCONNECTED; /* Clobber other states */

}

void

{

/*	so->so_state &= ~(SS_ISFCONNECTING|SS_ISFCONNECTED); */

/*	close(so->s); */

 * Set CANTSENDMORE once all data has been write()n

 */

void

{

	if (so->so_rcv.sb_cc)

		so->so_state |= SS_FWDRAIN;

	int flags;

	/*

	 * force pre-ESTABLISHED data up to user socket.

	 */

		goto present;

	/*

 * protocol specification dated September, 1981 very closely.

 */

void

{

  	struct ip save_ip, *ip;

	register struct tcpiphdr *ti;

	caddr_t optp = NULL;

	int optlen = 0;

	int len, tlen, off;

	register int tiflags;

	int todrop, acked, ourfinisacked, needoutput = 0;

/*	int dropsocket = 0; */

	int iss = 0;

		/* Re-set a few variables */

		tp = sototcpcb(so);

		m = so->so_m;

		ti = so->so_ti;

		tiwin = ti->ti_win;

		tiflags = ti->ti_flags;

	 * Checksum extended TCP header and data.

	 */

	tlen = ((struct ip *)ti)->ip_len;

	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 ((tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) != TH_SYN)

	    goto dropwithreset;

	tp = sototcpcb(so);

	/* XXX Should never fail */

		goto dropwithreset;

	if (tp->t_state == TCPS_CLOSED)

		goto drop;

 */

int

{

	struct socket *so = tp->t_socket;

	int mss;

 * Tcp output routine: figure out what should be sent and send it.

 */

int

{

	register struct socket *so = tp->t_socket;

	register long len, win;

}

void

{

    int t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1;

 * Tcp initialization

 */

void

{

	tcp_iss = 1;		/* wrong */

	tcb.so_next = tcb.so_prev = &tcb;

 */

/* struct tcpiphdr * */

void

{

	struct socket *so = tp->t_socket;

	register struct tcpiphdr *n = &tp->t_template;

 * segment are as specified by the parameters.

 */

void

{

	register int tlen;

	int win = 0;

	if (tp)

		win = sbspace(&tp->t_socket->so_rcv);

		if ((m = m_get()) == NULL)

			return;

#ifdef TCP_COMPAT_42

	tlen += sizeof (struct tcpiphdr);

	m->m_len = tlen;

	ti->ti_x1 = 0;

	ti->ti_seq = htonl(seq);

	ti->ti_ack = htonl(ack);

 * protocol control block.

 */

struct tcpcb *

{

	register struct tcpcb *tp;

 *	wake up any sleepers

 */

struct tcpcb *

{

	register struct tcpiphdr *t;

	struct socket *so = tp->t_socket;

 */

/*	free(tp, M_PCB);  */

	free(tp);

	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

{

	DEBUG_CALL("tcp_sockclosed");

 * nonblocking.  Connect returns after the SYN is sent, and does

 * not wait for ACK+SYN.

 */

{

  int ret=0;

 * here and SYN the local-host.

 */