/** * Open location * * @v intf Data transfer interface * @v type Location type * @v args Remaining arguments depend upon location type * @ret rc Return status code */ int xfer_vopen ( struct interface *intf, int type, va_list args ) { switch ( type ) { case LOCATION_URI_STRING: { const char *uri_string = va_arg ( args, const char * ); return xfer_open_uri_string ( intf, uri_string ); } case LOCATION_URI: { struct uri *uri = va_arg ( args, struct uri * ); return xfer_open_uri ( intf, uri ); } case LOCATION_SOCKET: { int semantics = va_arg ( args, int ); struct sockaddr *peer = va_arg ( args, struct sockaddr * ); struct sockaddr *local = va_arg ( args, struct sockaddr * ); return xfer_open_socket ( intf, semantics, peer, local ); } default: DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " attempted to " "open unsupported location type %d\n", INTF_DBG ( intf ), type ); return -ENOTSUP; } }
/** * Plug an object interface into a new destination object interface * * @v intf Object interface * @v dest New destination object interface * * The reference to the existing destination interface is dropped, a * reference to the new destination interface is obtained, and the * interface is updated to point to the new destination interface. * * Note that there is no "unplug" call; instead you must plug the * interface into a null interface. */ void intf_plug ( struct interface *intf, struct interface *dest ) { DBGC ( INTF_COL ( intf ), "INTF " INTF_INTF_FMT " replug to " INTF_FMT "\n", INTF_INTF_DBG ( intf, intf->dest ), INTF_DBG ( dest ) ); intf_get ( dest ); intf_put ( intf->dest ); intf->dest = dest; }
/** * Open socket * * @v intf Data transfer interface * @v semantics Communication semantics (e.g. SOCK_STREAM) * @v peer Peer socket address * @v local Local socket address, or NULL * @ret rc Return status code */ int xfer_open_socket ( struct interface *intf, int semantics, struct sockaddr *peer, struct sockaddr *local ) { struct socket_opener *opener; DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " opening (%s,%s) socket\n", INTF_DBG ( intf ), socket_semantics_name ( semantics ), socket_family_name ( peer->sa_family ) ); for_each_table_entry ( opener, SOCKET_OPENERS ) { if ( ( opener->semantics == semantics ) && ( opener->family == peer->sa_family ) ) { return opener->open ( intf, peer, local ); } } DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " attempted to open " "unsupported socket type (%s,%s)\n", INTF_DBG ( intf ), socket_semantics_name ( semantics ), socket_family_name ( peer->sa_family ) ); return -ENOTSUP; }
/** * Shut down an object interface * * @v intf Object interface * @v rc Reason for close * * Blocks further operations from being received via the interface, * executes a close operation on the destination interface, and * unplugs the interface. */ void intf_shutdown ( struct interface *intf, int rc ) { DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " shutting down (%s)\n", INTF_DBG ( intf ), strerror ( rc ) ); /* Block further operations */ intf_nullify ( intf ); /* Notify destination of close */ intf_close ( intf, rc ); /* Unplug interface */ intf_unplug ( intf ); }
/** * Open URI * * @v intf Data transfer interface * @v uri URI * @ret rc Return status code * * The URI will be regarded as being relative to the current working * URI (see churi()). */ int xfer_open_uri ( struct interface *intf, struct uri *uri ) { struct uri_opener *opener; struct uri *resolved_uri; int rc; /* Resolve URI */ resolved_uri = resolve_uri ( cwuri, uri ); if ( ! resolved_uri ) { rc = -ENOMEM; goto err_resolve_uri; } /* Find opener which supports this URI scheme */ opener = xfer_uri_opener ( resolved_uri->scheme ); if ( ! opener ) { DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " attempted to open " "unsupported URI scheme \"%s\"\n", INTF_DBG ( intf ), resolved_uri->scheme ); rc = -ENOTSUP; goto err_opener; } /* Call opener */ DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " opening %s URI\n", INTF_DBG ( intf ), resolved_uri->scheme ); if ( ( rc = opener->open ( intf, resolved_uri ) ) != 0 ) { DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " could not open: " "%s\n", INTF_DBG ( intf ), strerror ( rc ) ); goto err_open; } err_open: err_opener: uri_put ( resolved_uri ); err_resolve_uri: return rc; }
/** * Open URI string * * @v intf Data transfer interface * @v uri_string URI string (e.g. "http://ipxe.org/kernel") * @ret rc Return status code * * The URI will be regarded as being relative to the current working * URI (see churi()). */ int xfer_open_uri_string ( struct interface *intf, const char *uri_string ) { struct uri *uri; int rc; DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " opening URI %s\n", INTF_DBG ( intf ), uri_string ); uri = parse_uri ( uri_string ); if ( ! uri ) return -ENOMEM; rc = xfer_open_uri ( intf, uri ); uri_put ( uri ); return rc; }
/** * Shut down and restart an object interface * * @v intf Object interface * @v rc Reason for close * * Shuts down the interface, then unblocks operations that were * blocked during shutdown. */ void intf_restart ( struct interface *intf, int rc ) { struct interface_descriptor *desc = intf->desc; /* Shut down the interface */ intf_shutdown ( intf, rc ); DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " restarting\n", INTF_DBG ( intf ) ); /* Restore the interface descriptor. Must be done after * shutdown (rather than inhibiting intf_shutdown() from * nullifying the descriptor) in order to avoid a potential * infinite loop as the intf_close() operations on each side * of the link call each other recursively. */ intf->desc = desc; }
/** * Seek to position * * @v intf Data transfer interface * @v offset Offset to new position * @ret rc Return status code */ int xfer_seek ( struct interface *intf, off_t offset ) { struct io_buffer *iobuf; struct xfer_metadata meta = { .flags = XFER_FL_ABS_OFFSET, .offset = offset, }; DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " seek to %ld\n", INTF_DBG ( intf ), offset ); /* Allocate and send a zero-length data buffer */ iobuf = xfer_alloc_iob ( intf, 0 ); if ( ! iobuf ) return -ENOMEM; return xfer_deliver ( intf, iobuf, &meta ); }