cdef onload

cdef onerror

cdef arg

def __cinit__(self, onload, onerror, arg):

self.onload = onload

self.onerror = onerror

self.arg = arg

#def __dealloc__(self):

cdef pycaller_async_wget c = pycaller_async_wget(onload, onerror, arg)

cdef PyObject* p = <PyObject*>c

Py_XINCREF(p) # survive until callback

emscripten_async_wget_data(url.encode('UTF-8'), p,

pycaller_callback_async_wget_onload,

cdef emscripten_fetch_t *fetch

cdef callbacks

def __cinit__(self, url, requestMethod=None, userData=None,

onsuccess=None, onerror=None, onprogress=None, onreadystatechange=None,

attributes=None, timeoutMSecs=None, withCredentials=None,

destinationPath=None, userName=None, password=None,

requestHeaders=None, overriddenMimeType=None, requestData=None):

# Keep track of temporary Python strings we pass emscripten_fetch() for copy

py_str_refs = []

cdef emscripten_fetch_attr_t attr

emscripten_fetch_attr_init(&attr)

Py_XINCREF(<PyObject*>self) # survive until callback

attr.userData = <PyObject*>self

if requestMethod is not None:

strncpy(attr.requestMethod,

requestMethod.encode('UTF-8'),

sizeof(attr.requestMethod) - 1)

self.userData = userData

self.callbacks = {}

attr.onsuccess = callpyfunc_fetch_onsuccess

attr.onerror = callpyfunc_fetch_onerror

if onsuccess is not None:

self.callbacks['onsuccess'] = onsuccess

if onerror is not None:

self.callbacks['onerror'] = onerror

if onprogress is not None:

self.callbacks['onprogress'] = onprogress

attr.onprogress = callpyfunc_fetch_onprogress

if onreadystatechange is not None:

self.callbacks['onreadystatechange'] = onreadystatechange

attr.onreadystatechange = callpyfunc_fetch_onreadystatechange

if attributes is not None:

attr.attributes = attributes

if timeoutMSecs is not None:

attr.timeoutMSecs = timeoutMSecs

if withCredentials is not None:

attr.withCredentials = withCredentials

if destinationPath is not None:

py_str_refs.append(destinationPath.encode('UTF-8'))

attr.destinationPath = py_str_refs[-1]

if userName is not None:

py_str_refs.append(userName.encode('UTF-8'))

attr.userName = py_str_refs[-1]

if password is not None:

py_str_refs.append(password.encode('UTF-8'))

attr.password = py_str_refs[-1]

cdef char** headers

if requestHeaders is not None:

size = (2 * len(requestHeaders) + 1) * sizeof(char*)

headers = <char**>PyMem_Malloc(size)

i = 0

for name,value in requestHeaders.items():

py_str_refs.append(name.encode('UTF-8'))

headers[i] = py_str_refs[-1]

i += 1

py_str_refs.append(value.encode('UTF-8'))

headers[i] = py_str_refs[-1]

i += 1

headers[i] = NULL

attr.requestHeaders = <const char* const *>headers

if overriddenMimeType is not None:

py_str_refs.append(overriddenMimeType.encode('UTF-8'))

attr.overriddenMimeType = py_str_refs[-1]

if requestData is not None:

size = len(requestData)

attr.requestDataSize = size

# direct pointer, no UTF-8 encoding pass:

attr.requestData = requestData

# Fetch

cdef emscripten_fetch_t *fetch = emscripten_fetch(&attr, url.encode('UTF-8'))

self.fetch = fetch

# Explicitely deref temporary Python strings. Test for forgotten refs with e.g.:

# print(attr.overriddenMimeType, attr.destinationPath, attr.userName, attr.password)

del py_str_refs

if requestHeaders is not None:

PyMem_Free(<void*>attr.requestHeaders)

def __dealloc__(self):

emscripten_fetch_close(self.fetch)

# Currently unsafe:

# https://github.com/emscripten-core/emscripten/issues/8234

#def fetch_close(fetch):

# pass

# http://docs.cython.org/en/latest/src/userguide/buffer.html

# https://docs.python.org/3/c-api/typeobj.html#c.PyBufferProcs.bf_getbuffer

# https://docs.python.org/3/c-api/buffer.html#c.PyObject_GetBuffer

# https://docs.python.org/3/c-api/buffer.html#c.PyBuffer_FillInfo

def __getbuffer__(self, Py_buffer *view, int flags):

if self.fetch.data != NULL:

is_readonly = 1

PyBuffer_FillInfo(view, self, <void*>self.fetch.data, self.fetch.numBytes, is_readonly, flags)

else:

view.obj = None

raise BufferError

def __releasebuffer__(self, Py_buffer *view):

pass

def __repr__(self):

return u'<Fetch: id={}, userData={}, url={}, data={}, dataOffset={}, totalBytes={}, readyState={}, status={}, statusText={}>'.format(repr(self.id), repr(self.userData), repr(self.url), repr(self.data), repr(self.dataOffset), repr(self.totalBytes), repr(self.readyState), repr(self.status), repr(self.statusText))

# For testing whether a copy occurred:

#def overwrite(self):

# cdef char* overwrite = <char*>(self.fetch.data)

# overwrite[0] = b'O'

def get_response_headers(self):

cdef char* buf = NULL

# Note: JS crash if applied on a persisted request from IDB cache

# https://github.com/emscripten-core/emscripten/issues/7026#issuecomment-545488132

cdef length = emscripten_fetch_get_response_headers_length(self.fetch)

if length > 0:

headersString = <char*>PyMem_Malloc(length)

emscripten_fetch_get_response_headers(self.fetch, headersString, length+1)

ret = headersString[:length] # copy

PyMem_Free(headersString)

return ret

else:

return None

def get_unpacked_response_headers(self):

cdef char* headersString = NULL

cdef char** unpackedHeaders = NULL

# Note: JS crash if applied on a persisted request from IDB cache

cdef length = emscripten_fetch_get_response_headers_length(self.fetch)

if length > 0:

headersString = <char*>PyMem_Malloc(length)

emscripten_fetch_get_response_headers(self.fetch, headersString, length+1)

unpackedHeaders = emscripten_fetch_unpack_response_headers(headersString)

PyMem_Free(headersString)

d = {}

i = 0

while unpackedHeaders[i] != NULL:

k = unpackedHeaders[i] # c_string_encoding

i += 1

v = unpackedHeaders[i] # c_string_encoding

i += 1

d[k] = v

emscripten_fetch_free_unpacked_response_headers(unpackedHeaders)

return d

else:

return None

@property

def id(self):

return self.fetch.id

cdef readonly userData

@property

def url(self):

#return self.fetch.url.decode('UTF-8')

return self.fetch.url # c_string_encoding

@property

def data(self):

if self.fetch.data != NULL:

return self

else:

return None

@property

def dataOffset(self):

return self.fetch.dataOffset

@property

def totalBytes(self):

return self.fetch.totalBytes # Content-Length

@property

def readyState(self):

return self.fetch.readyState

@property

def status(self):

return self.fetch.status

@property

def statusText(self):

#return self.fetch.statusText.decode('UTF-8')

cdef void* amb = <void*>emscripten_get_compiler_setting(name.encode('UTF-8'))

# can be int or char*, use heuristic

# otherwise we could whitelist all known string parameters, if that's possible

if <int>amb < 1000:

return <int>amb

else:

# No variadic function support in Cython?

# No va_arg variant for emscripten_log either.

# Let's offer limited support

cdef char* format

cdef char* cstr

if len(args) == 0:

emscripten_log(flags)

elif len(args) > 0:

format = args[0]

if len(args) == 1:

emscripten_log(flags, format)

elif len(args) == 2:

arg = args[1]

if type(arg) == int:

emscripten_log(flags, format, <int>arg)

elif type(arg) == float:

emscripten_log(flags, format, <float>arg)

elif type(arg) in (str, unicode):

pystr = arg.encode('UTF-8')

cstr = pystr

emscripten_log(flags, format, cstr)

else:

pystr = ("emscripten.log: unsupported argument " + str(type(arg))).encode('UTF-8')

cstr = pystr

emscripten_log(flags, cstr)

else:

cdef int size = emscripten_get_callstack(flags, NULL, 0)

# "subsequent calls will carry different line numbers, so it is

# best to allocate a few bytes extra to be safe"

size += 1024

cdef char* buf = <char*>PyMem_Malloc(size)

emscripten_get_callstack(flags, buf, size)

cdef object ret = buf # c_string_encoding

PyMem_Free(buf)

cdef char *buf

cdef int size

def __init__(self):

raise Exception("MallocBuffer: constructor not available from Python")

# constructor from non-Python parameters (__cinit__ don't accept them)

@staticmethod

cdef MallocBuffer from_string_and_size(char* buf, int size):

cdef MallocBuffer ret = MallocBuffer.__new__(MallocBuffer)

ret.buf = buf

ret.size = size

cdef char* buf

cdef int num, error

emscripten_wget_data(url.encode('UTF-8'), <void**>&buf, &num, &error)

if error != 0:

return None

pybuf = MallocBuffer.from_string_and_size(buf, num)

emscripten_run_script(r"""