@php-wasm/web-8-0 3.0.44 → 3.0.46

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Binary file
@@ -4929,171 +4929,532 @@ export function init(RuntimeName, PHPLoader) {
4929
4929
  }
4930
4930
  }
4931
4931
  ___syscall_chmod.sig = 'ipi';
4932
- function ___syscall_connect(fd, addr, addrlen, d1, d2, d3) {
4933
- try {
4934
- var sock = getSocketFromFD(fd);
4935
- var info = getSocketAddress(addr, addrlen);
4936
- sock.sock_ops.connect(sock, info.addr, info.port);
4937
- return 0;
4938
- } catch (e) {
4939
- if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
4940
- return -e.errno;
4941
- }
4942
- }
4943
- ___syscall_connect.sig = 'iippiii';
4944
- function ___syscall_dup(fd) {
4945
- try {
4946
- var old = SYSCALLS.getStreamFromFD(fd);
4947
- return FS.dupStream(old).fd;
4948
- } catch (e) {
4949
- if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
4950
- return -e.errno;
4951
- }
4932
+ var allocateUTF8OnStack = (...args) => stringToUTF8OnStack(...args);
4933
+ function _js_getpid() {
4934
+ return PHPLoader.processId ?? 42;
4952
4935
  }
4953
- ___syscall_dup.sig = 'ii';
4954
- function ___syscall_dup3(fd, newfd, flags) {
4955
- try {
4956
- var old = SYSCALLS.getStreamFromFD(fd);
4957
- if (old.fd === newfd) return -28;
4958
- if (newfd < 0 || newfd >= FS.MAX_OPEN_FDS) return -8;
4959
- var existing = FS.getStream(newfd);
4960
- if (existing) FS.close(existing);
4961
- return FS.dupStream(old, newfd).fd;
4962
- } catch (e) {
4963
- if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
4964
- return -e.errno;
4936
+ function _js_wasm_trace(format, ...args) {
4937
+ if (PHPLoader.trace instanceof Function) {
4938
+ PHPLoader.trace(_js_getpid(), format, ...args);
4965
4939
  }
4966
4940
  }
4967
- ___syscall_dup3.sig = 'iiii';
4968
- function ___syscall_faccessat(dirfd, path, amode, flags) {
4969
- try {
4970
- path = SYSCALLS.getStr(path);
4971
- path = SYSCALLS.calculateAt(dirfd, path);
4972
- if (amode & ~7) {
4973
- return -28;
4941
+ var PHPWASM = {
4942
+ O_APPEND: 1024,
4943
+ O_NONBLOCK: 2048,
4944
+ POLLHUP: 16,
4945
+ SETFL_MASK: 3072,
4946
+ init: function (phpWasmInitOptions) {
4947
+ Module['ENV'] = Module['ENV'] || {};
4948
+ Module['ENV']['PATH'] = [
4949
+ Module['ENV']['PATH'],
4950
+ '/internal/shared/bin',
4951
+ ]
4952
+ .filter(Boolean)
4953
+ .join(':');
4954
+ FS.mkdir('/request');
4955
+ FS.mkdir('/internal');
4956
+ if (phpWasmInitOptions?.nativeInternalDirPath) {
4957
+ FS.mount(
4958
+ FS.filesystems.NODEFS,
4959
+ { root: phpWasmInitOptions.nativeInternalDirPath },
4960
+ '/internal'
4961
+ );
4974
4962
  }
4975
- var lookup = FS.lookupPath(path, { follow: true });
4976
- var node = lookup.node;
4977
- if (!node) {
4978
- return -44;
4963
+ FS.mkdirTree('/internal/shared');
4964
+ FS.mkdirTree('/internal/shared/preload');
4965
+ FS.mkdirTree('/internal/shared/bin');
4966
+ const originalOnRuntimeInitialized = Module['onRuntimeInitialized'];
4967
+ Module['onRuntimeInitialized'] = () => {
4968
+ const { node: phpBinaryNode } = FS.lookupPath(
4969
+ '/internal/shared/bin/php',
4970
+ { noent_okay: true }
4971
+ );
4972
+ if (!phpBinaryNode) {
4973
+ FS.writeFile(
4974
+ '/internal/shared/bin/php',
4975
+ new TextEncoder().encode('#!/bin/sh\nphp "$@"')
4976
+ );
4977
+ FS.chmod('/internal/shared/bin/php', 493);
4978
+ }
4979
+ originalOnRuntimeInitialized();
4980
+ };
4981
+ FS.registerDevice(FS.makedev(64, 0), {
4982
+ open: () => {},
4983
+ close: () => {},
4984
+ read: () => 0,
4985
+ write: (stream, buffer, offset, length, pos) => {
4986
+ const chunk = buffer.subarray(offset, offset + length);
4987
+ PHPWASM.onStdout(chunk);
4988
+ return length;
4989
+ },
4990
+ });
4991
+ FS.mkdev('/request/stdout', FS.makedev(64, 0));
4992
+ FS.registerDevice(FS.makedev(63, 0), {
4993
+ open: () => {},
4994
+ close: () => {},
4995
+ read: () => 0,
4996
+ write: (stream, buffer, offset, length, pos) => {
4997
+ const chunk = buffer.subarray(offset, offset + length);
4998
+ PHPWASM.onStderr(chunk);
4999
+ return length;
5000
+ },
5001
+ });
5002
+ FS.mkdev('/request/stderr', FS.makedev(63, 0));
5003
+ FS.registerDevice(FS.makedev(62, 0), {
5004
+ open: () => {},
5005
+ close: () => {},
5006
+ read: () => 0,
5007
+ write: (stream, buffer, offset, length, pos) => {
5008
+ const chunk = buffer.subarray(offset, offset + length);
5009
+ PHPWASM.onHeaders(chunk);
5010
+ return length;
5011
+ },
5012
+ });
5013
+ FS.mkdev('/request/headers', FS.makedev(62, 0));
5014
+ PHPWASM.EventEmitter = ENVIRONMENT_IS_NODE
5015
+ ? require('events').EventEmitter
5016
+ : class EventEmitter {
5017
+ constructor() {
5018
+ this.listeners = {};
5019
+ }
5020
+ emit(eventName, data) {
5021
+ if (this.listeners[eventName]) {
5022
+ this.listeners[eventName].forEach(
5023
+ (callback) => {
5024
+ callback(data);
5025
+ }
5026
+ );
5027
+ }
5028
+ }
5029
+ once(eventName, callback) {
5030
+ const self = this;
5031
+ function removedCallback() {
5032
+ callback(...arguments);
5033
+ self.removeListener(eventName, removedCallback);
5034
+ }
5035
+ this.on(eventName, removedCallback);
5036
+ }
5037
+ removeAllListeners(eventName) {
5038
+ if (eventName) {
5039
+ delete this.listeners[eventName];
5040
+ } else {
5041
+ this.listeners = {};
5042
+ }
5043
+ }
5044
+ removeListener(eventName, callback) {
5045
+ if (this.listeners[eventName]) {
5046
+ const idx =
5047
+ this.listeners[eventName].indexOf(callback);
5048
+ if (idx !== -1) {
5049
+ this.listeners[eventName].splice(idx, 1);
5050
+ }
5051
+ }
5052
+ }
5053
+ };
5054
+ PHPWASM.processTable = {};
5055
+ PHPWASM.input_devices = {};
5056
+ const originalWrite = TTY.stream_ops.write;
5057
+ TTY.stream_ops.write = function (stream, ...rest) {
5058
+ const retval = originalWrite(stream, ...rest);
5059
+ stream.tty.ops.fsync(stream.tty);
5060
+ return retval;
5061
+ };
5062
+ const originalPutChar = TTY.stream_ops.put_char;
5063
+ TTY.stream_ops.put_char = function (tty, val) {
5064
+ if (val === 10) tty.output.push(val);
5065
+ return originalPutChar(tty, val);
5066
+ };
5067
+ },
5068
+ onHeaders: function (chunk) {
5069
+ if (Module['onHeaders']) {
5070
+ Module['onHeaders'](chunk);
5071
+ return;
4979
5072
  }
4980
- var perms = '';
4981
- if (amode & 4) perms += 'r';
4982
- if (amode & 2) perms += 'w';
4983
- if (amode & 1) perms += 'x';
4984
- if (perms && FS.nodePermissions(node, perms)) {
4985
- return -2;
5073
+ console.log('headers', { chunk });
5074
+ },
5075
+ onStdout: function (chunk) {
5076
+ if (Module['onStdout']) {
5077
+ Module['onStdout'](chunk);
5078
+ return;
4986
5079
  }
4987
- return 0;
4988
- } catch (e) {
4989
- if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
4990
- return -e.errno;
4991
- }
4992
- }
4993
- ___syscall_faccessat.sig = 'iipii';
4994
- var ___syscall_fadvise64 = (fd, offset, len, advice) => 0;
4995
- ___syscall_fadvise64.sig = 'iijji';
4996
- var INT53_MAX = 9007199254740992;
4997
- var INT53_MIN = -9007199254740992;
4998
- var bigintToI53Checked = (num) =>
4999
- num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
5000
- function ___syscall_fallocate(fd, mode, offset, len) {
5001
- offset = bigintToI53Checked(offset);
5002
- len = bigintToI53Checked(len);
5003
- try {
5004
- if (isNaN(offset) || isNaN(len)) return -61;
5005
- if (mode != 0) {
5006
- return -138;
5080
+ if (ENVIRONMENT_IS_NODE) {
5081
+ process.stdout.write(chunk);
5082
+ } else {
5083
+ console.log('stdout', { chunk });
5007
5084
  }
5008
- if (offset < 0 || len < 0) {
5009
- return -28;
5085
+ },
5086
+ onStderr: function (chunk) {
5087
+ if (Module['onStderr']) {
5088
+ Module['onStderr'](chunk);
5089
+ return;
5010
5090
  }
5011
- var oldSize = FS.fstat(fd).size;
5012
- var newSize = offset + len;
5013
- if (newSize > oldSize) {
5014
- FS.ftruncate(fd, newSize);
5091
+ if (ENVIRONMENT_IS_NODE) {
5092
+ process.stderr.write(chunk);
5093
+ } else {
5094
+ console.warn('stderr', { chunk });
5015
5095
  }
5016
- return 0;
5017
- } catch (e) {
5018
- if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
5019
- return -e.errno;
5020
- }
5021
- }
5022
- ___syscall_fallocate.sig = 'iiijj';
5023
- function ___syscall_fchdir(fd) {
5024
- try {
5025
- var stream = SYSCALLS.getStreamFromFD(fd);
5026
- FS.chdir(stream.path);
5027
- return 0;
5028
- } catch (e) {
5029
- if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
5030
- return -e.errno;
5031
- }
5032
- }
5033
- ___syscall_fchdir.sig = 'ii';
5034
- function ___syscall_fchmod(fd, mode) {
5035
- try {
5036
- FS.fchmod(fd, mode);
5037
- return 0;
5038
- } catch (e) {
5039
- if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
5040
- return -e.errno;
5041
- }
5042
- }
5043
- ___syscall_fchmod.sig = 'iii';
5044
- function ___syscall_fchmodat2(dirfd, path, mode, flags) {
5096
+ },
5097
+ getAllWebSockets: function (sock) {
5098
+ const webSockets = new Set();
5099
+ if (sock.server) {
5100
+ sock.server.clients.forEach((ws) => {
5101
+ webSockets.add(ws);
5102
+ });
5103
+ }
5104
+ for (const peer of PHPWASM.getAllPeers(sock)) {
5105
+ webSockets.add(peer.socket);
5106
+ }
5107
+ return Array.from(webSockets);
5108
+ },
5109
+ getAllPeers: function (sock) {
5110
+ const peers = new Set();
5111
+ if (sock.server) {
5112
+ sock.pending
5113
+ .filter((pending) => pending.peers)
5114
+ .forEach((pending) => {
5115
+ for (const peer of Object.values(pending.peers)) {
5116
+ peers.add(peer);
5117
+ }
5118
+ });
5119
+ }
5120
+ if (sock.peers) {
5121
+ for (const peer of Object.values(sock.peers)) {
5122
+ peers.add(peer);
5123
+ }
5124
+ }
5125
+ return Array.from(peers);
5126
+ },
5127
+ awaitData: function (ws) {
5128
+ return PHPWASM.awaitEvent(ws, 'message');
5129
+ },
5130
+ awaitConnection: function (ws) {
5131
+ if (ws.OPEN === ws.readyState) {
5132
+ return [Promise.resolve(), PHPWASM.noop];
5133
+ }
5134
+ return PHPWASM.awaitEvent(ws, 'open');
5135
+ },
5136
+ awaitClose: function (ws) {
5137
+ if ([ws.CLOSING, ws.CLOSED].includes(ws.readyState)) {
5138
+ return [Promise.resolve(), PHPWASM.noop];
5139
+ }
5140
+ return PHPWASM.awaitEvent(ws, 'close');
5141
+ },
5142
+ awaitError: function (ws) {
5143
+ if ([ws.CLOSING, ws.CLOSED].includes(ws.readyState)) {
5144
+ return [Promise.resolve(), PHPWASM.noop];
5145
+ }
5146
+ return PHPWASM.awaitEvent(ws, 'error');
5147
+ },
5148
+ awaitEvent: function (ws, event) {
5149
+ let resolve;
5150
+ const listener = () => {
5151
+ resolve();
5152
+ };
5153
+ const promise = new Promise(function (_resolve) {
5154
+ resolve = _resolve;
5155
+ ws.once(event, listener);
5156
+ });
5157
+ const cancel = () => {
5158
+ ws.removeListener(event, listener);
5159
+ setTimeout(resolve);
5160
+ };
5161
+ return [promise, cancel];
5162
+ },
5163
+ noop: function () {},
5164
+ spawnProcess: function (command, args, options) {
5165
+ if (Module['spawnProcess']) {
5166
+ const spawned = Module['spawnProcess'](command, args, {
5167
+ ...options,
5168
+ shell: true,
5169
+ stdio: ['pipe', 'pipe', 'pipe'],
5170
+ });
5171
+ if (spawned && !('then' in spawned) && 'on' in spawned) {
5172
+ return spawned;
5173
+ }
5174
+ return Promise.resolve(spawned).then(function (spawned) {
5175
+ if (!spawned || !spawned.on) {
5176
+ throw new Error(
5177
+ 'spawnProcess() must return an EventEmitter but returned a different type.'
5178
+ );
5179
+ }
5180
+ return spawned;
5181
+ });
5182
+ }
5183
+ const e = new Error(
5184
+ 'popen(), proc_open() etc. are unsupported on this PHP instance. Call php.setSpawnHandler() ' +
5185
+ 'and provide a callback to handle spawning processes, or disable a popen(), proc_open() ' +
5186
+ 'and similar functions via php.ini.'
5187
+ );
5188
+ e.code = 'SPAWN_UNSUPPORTED';
5189
+ throw e;
5190
+ },
5191
+ shutdownSocket: function (socketd, how) {
5192
+ const sock = getSocketFromFD(socketd);
5193
+ const peer = Object.values(sock.peers)[0];
5194
+ if (!peer) {
5195
+ return -1;
5196
+ }
5197
+ try {
5198
+ peer.socket.close();
5199
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
5200
+ return 0;
5201
+ } catch (e) {
5202
+ console.log('Socket shutdown error', e);
5203
+ return -1;
5204
+ }
5205
+ },
5206
+ };
5207
+ function _wasm_connect(sockfd, addr, addrlen) {
5208
+ if (!('Suspending' in WebAssembly)) {
5209
+ var sock = getSocketFromFD(sockfd);
5210
+ var info = getSocketAddress(addr, addrlen);
5211
+ sock.sock_ops.connect(sock, info.addr, info.port);
5212
+ return 0;
5213
+ }
5214
+ return Asyncify.handleSleep((wakeUp) => {
5215
+ let sock;
5216
+ try {
5217
+ sock = getSocketFromFD(sockfd);
5218
+ } catch (e) {
5219
+ wakeUp(-ERRNO_CODES.EBADF);
5220
+ return;
5221
+ }
5222
+ if (!sock) {
5223
+ wakeUp(-ERRNO_CODES.EBADF);
5224
+ return;
5225
+ }
5226
+ let info;
5227
+ try {
5228
+ info = getSocketAddress(addr, addrlen);
5229
+ } catch (e) {
5230
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) {
5231
+ wakeUp(-ERRNO_CODES.EFAULT);
5232
+ return;
5233
+ }
5234
+ wakeUp(-e.errno);
5235
+ return;
5236
+ }
5237
+ try {
5238
+ sock.sock_ops.connect(sock, info.addr, info.port);
5239
+ } catch (e) {
5240
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) {
5241
+ wakeUp(-ERRNO_CODES.ECONNREFUSED);
5242
+ return;
5243
+ }
5244
+ wakeUp(-e.errno);
5245
+ return;
5246
+ }
5247
+ const webSockets = PHPWASM.getAllWebSockets(sock);
5248
+ if (!webSockets.length) {
5249
+ wakeUp(-ERRNO_CODES.ECONNREFUSED);
5250
+ return;
5251
+ }
5252
+ const ws = webSockets[0];
5253
+ if (ws.readyState === ws.OPEN) {
5254
+ wakeUp(0);
5255
+ return;
5256
+ }
5257
+ if (ws.readyState === ws.CLOSING || ws.readyState === ws.CLOSED) {
5258
+ wakeUp(-ERRNO_CODES.ECONNREFUSED);
5259
+ return;
5260
+ }
5261
+ const timeout = 3e4;
5262
+ let resolved = false;
5263
+ const timeoutId = setTimeout(() => {
5264
+ if (!resolved) {
5265
+ resolved = true;
5266
+ wakeUp(-ERRNO_CODES.ETIMEDOUT);
5267
+ }
5268
+ }, timeout);
5269
+ const handleOpen = () => {
5270
+ if (!resolved) {
5271
+ resolved = true;
5272
+ clearTimeout(timeoutId);
5273
+ ws.removeEventListener('error', handleError);
5274
+ ws.removeEventListener('close', handleClose);
5275
+ wakeUp(0);
5276
+ }
5277
+ };
5278
+ const handleError = () => {
5279
+ if (!resolved) {
5280
+ resolved = true;
5281
+ clearTimeout(timeoutId);
5282
+ ws.removeEventListener('open', handleOpen);
5283
+ ws.removeEventListener('close', handleClose);
5284
+ wakeUp(-ERRNO_CODES.ECONNREFUSED);
5285
+ }
5286
+ };
5287
+ const handleClose = () => {
5288
+ if (!resolved) {
5289
+ resolved = true;
5290
+ clearTimeout(timeoutId);
5291
+ ws.removeEventListener('open', handleOpen);
5292
+ ws.removeEventListener('error', handleError);
5293
+ wakeUp(-ERRNO_CODES.ECONNREFUSED);
5294
+ }
5295
+ };
5296
+ ws.addEventListener('open', handleOpen);
5297
+ ws.addEventListener('error', handleError);
5298
+ ws.addEventListener('close', handleClose);
5299
+ });
5300
+ }
5301
+ function ___syscall_connect(sockfd, addr, addrlen, d1, d2, d3) {
5302
+ return _wasm_connect(sockfd, addr, addrlen);
5303
+ }
5304
+ ___syscall_connect.sig = 'iippiii';
5305
+ function ___syscall_dup(fd) {
5306
+ try {
5307
+ var old = SYSCALLS.getStreamFromFD(fd);
5308
+ return FS.dupStream(old).fd;
5309
+ } catch (e) {
5310
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
5311
+ return -e.errno;
5312
+ }
5313
+ }
5314
+ ___syscall_dup.sig = 'ii';
5315
+ function ___syscall_dup3(fd, newfd, flags) {
5316
+ try {
5317
+ var old = SYSCALLS.getStreamFromFD(fd);
5318
+ if (old.fd === newfd) return -28;
5319
+ if (newfd < 0 || newfd >= FS.MAX_OPEN_FDS) return -8;
5320
+ var existing = FS.getStream(newfd);
5321
+ if (existing) FS.close(existing);
5322
+ return FS.dupStream(old, newfd).fd;
5323
+ } catch (e) {
5324
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
5325
+ return -e.errno;
5326
+ }
5327
+ }
5328
+ ___syscall_dup3.sig = 'iiii';
5329
+ function ___syscall_faccessat(dirfd, path, amode, flags) {
5045
5330
  try {
5046
- var nofollow = flags & 256;
5047
5331
  path = SYSCALLS.getStr(path);
5048
5332
  path = SYSCALLS.calculateAt(dirfd, path);
5049
- FS.chmod(path, mode, nofollow);
5333
+ if (amode & ~7) {
5334
+ return -28;
5335
+ }
5336
+ var lookup = FS.lookupPath(path, { follow: true });
5337
+ var node = lookup.node;
5338
+ if (!node) {
5339
+ return -44;
5340
+ }
5341
+ var perms = '';
5342
+ if (amode & 4) perms += 'r';
5343
+ if (amode & 2) perms += 'w';
5344
+ if (amode & 1) perms += 'x';
5345
+ if (perms && FS.nodePermissions(node, perms)) {
5346
+ return -2;
5347
+ }
5050
5348
  return 0;
5051
5349
  } catch (e) {
5052
5350
  if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
5053
5351
  return -e.errno;
5054
5352
  }
5055
5353
  }
5056
- ___syscall_fchmodat2.sig = 'iipii';
5057
- function ___syscall_fchown32(fd, owner, group) {
5354
+ ___syscall_faccessat.sig = 'iipii';
5355
+ var ___syscall_fadvise64 = (fd, offset, len, advice) => 0;
5356
+ ___syscall_fadvise64.sig = 'iijji';
5357
+ var INT53_MAX = 9007199254740992;
5358
+ var INT53_MIN = -9007199254740992;
5359
+ var bigintToI53Checked = (num) =>
5360
+ num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
5361
+ function ___syscall_fallocate(fd, mode, offset, len) {
5362
+ offset = bigintToI53Checked(offset);
5363
+ len = bigintToI53Checked(len);
5058
5364
  try {
5059
- FS.fchown(fd, owner, group);
5365
+ if (isNaN(offset) || isNaN(len)) return -61;
5366
+ if (mode != 0) {
5367
+ return -138;
5368
+ }
5369
+ if (offset < 0 || len < 0) {
5370
+ return -28;
5371
+ }
5372
+ var oldSize = FS.fstat(fd).size;
5373
+ var newSize = offset + len;
5374
+ if (newSize > oldSize) {
5375
+ FS.ftruncate(fd, newSize);
5376
+ }
5060
5377
  return 0;
5061
5378
  } catch (e) {
5062
5379
  if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
5063
5380
  return -e.errno;
5064
5381
  }
5065
5382
  }
5066
- ___syscall_fchown32.sig = 'iiii';
5067
- function ___syscall_fchownat(dirfd, path, owner, group, flags) {
5383
+ ___syscall_fallocate.sig = 'iiijj';
5384
+ function ___syscall_fchdir(fd) {
5068
5385
  try {
5069
- path = SYSCALLS.getStr(path);
5070
- var nofollow = flags & 256;
5071
- flags = flags & ~256;
5072
- path = SYSCALLS.calculateAt(dirfd, path);
5073
- (nofollow ? FS.lchown : FS.chown)(path, owner, group);
5386
+ var stream = SYSCALLS.getStreamFromFD(fd);
5387
+ FS.chdir(stream.path);
5074
5388
  return 0;
5075
5389
  } catch (e) {
5076
5390
  if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
5077
5391
  return -e.errno;
5078
5392
  }
5079
5393
  }
5080
- ___syscall_fchownat.sig = 'iipiii';
5081
- var syscallGetVarargI = () => {
5082
- var ret = HEAP32[+SYSCALLS.varargs >> 2];
5083
- SYSCALLS.varargs += 4;
5084
- return ret;
5085
- };
5086
- var syscallGetVarargP = syscallGetVarargI;
5087
- function ___syscall_fcntl64(fd, cmd, varargs) {
5088
- SYSCALLS.varargs = varargs;
5394
+ ___syscall_fchdir.sig = 'ii';
5395
+ function ___syscall_fchmod(fd, mode) {
5089
5396
  try {
5090
- var stream = SYSCALLS.getStreamFromFD(fd);
5091
- switch (cmd) {
5092
- case 0: {
5093
- var arg = syscallGetVarargI();
5094
- if (arg < 0) {
5095
- return -28;
5096
- }
5397
+ FS.fchmod(fd, mode);
5398
+ return 0;
5399
+ } catch (e) {
5400
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
5401
+ return -e.errno;
5402
+ }
5403
+ }
5404
+ ___syscall_fchmod.sig = 'iii';
5405
+ function ___syscall_fchmodat2(dirfd, path, mode, flags) {
5406
+ try {
5407
+ var nofollow = flags & 256;
5408
+ path = SYSCALLS.getStr(path);
5409
+ path = SYSCALLS.calculateAt(dirfd, path);
5410
+ FS.chmod(path, mode, nofollow);
5411
+ return 0;
5412
+ } catch (e) {
5413
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
5414
+ return -e.errno;
5415
+ }
5416
+ }
5417
+ ___syscall_fchmodat2.sig = 'iipii';
5418
+ function ___syscall_fchown32(fd, owner, group) {
5419
+ try {
5420
+ FS.fchown(fd, owner, group);
5421
+ return 0;
5422
+ } catch (e) {
5423
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
5424
+ return -e.errno;
5425
+ }
5426
+ }
5427
+ ___syscall_fchown32.sig = 'iiii';
5428
+ function ___syscall_fchownat(dirfd, path, owner, group, flags) {
5429
+ try {
5430
+ path = SYSCALLS.getStr(path);
5431
+ var nofollow = flags & 256;
5432
+ flags = flags & ~256;
5433
+ path = SYSCALLS.calculateAt(dirfd, path);
5434
+ (nofollow ? FS.lchown : FS.chown)(path, owner, group);
5435
+ return 0;
5436
+ } catch (e) {
5437
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
5438
+ return -e.errno;
5439
+ }
5440
+ }
5441
+ ___syscall_fchownat.sig = 'iipiii';
5442
+ var syscallGetVarargI = () => {
5443
+ var ret = HEAP32[+SYSCALLS.varargs >> 2];
5444
+ SYSCALLS.varargs += 4;
5445
+ return ret;
5446
+ };
5447
+ var syscallGetVarargP = syscallGetVarargI;
5448
+ function ___syscall_fcntl64(fd, cmd, varargs) {
5449
+ SYSCALLS.varargs = varargs;
5450
+ try {
5451
+ var stream = SYSCALLS.getStreamFromFD(fd);
5452
+ switch (cmd) {
5453
+ case 0: {
5454
+ var arg = syscallGetVarargI();
5455
+ if (arg < 0) {
5456
+ return -28;
5457
+ }
5097
5458
  while (FS.streams[arg]) {
5098
5459
  arg++;
5099
5460
  }
@@ -12895,441 +13256,166 @@ export function init(RuntimeName, PHPLoader) {
12895
13256
  if (flags & 32) {
12896
13257
  return -2;
12897
13258
  }
12898
- if (type !== 0 && type !== 1 && type !== 2) {
12899
- return -7;
12900
- }
12901
- if (family !== 0 && family !== 2 && family !== 10) {
12902
- return -6;
12903
- }
12904
- if (service) {
12905
- service = UTF8ToString(service);
12906
- port = parseInt(service, 10);
12907
- if (isNaN(port)) {
12908
- if (flags & 1024) {
12909
- return -2;
12910
- }
12911
- return -8;
12912
- }
12913
- }
12914
- if (!node) {
12915
- if (family === 0) {
12916
- family = 2;
12917
- }
12918
- if ((flags & 1) === 0) {
12919
- if (family === 2) {
12920
- addr = _htonl(2130706433);
12921
- } else {
12922
- addr = [0, 0, 0, _htonl(1)];
12923
- }
12924
- }
12925
- ai = allocaddrinfo(family, type, proto, null, addr, port);
12926
- HEAPU32[out >> 2] = ai;
12927
- return 0;
12928
- }
12929
- node = UTF8ToString(node);
12930
- addr = inetPton4(node);
12931
- if (addr !== null) {
12932
- if (family === 0 || family === 2) {
12933
- family = 2;
12934
- } else if (family === 10 && flags & 8) {
12935
- addr = [0, 0, _htonl(65535), addr];
12936
- family = 10;
12937
- } else {
12938
- return -2;
12939
- }
12940
- } else {
12941
- addr = inetPton6(node);
12942
- if (addr !== null) {
12943
- if (family === 0 || family === 10) {
12944
- family = 10;
12945
- } else {
12946
- return -2;
12947
- }
12948
- }
12949
- }
12950
- if (addr != null) {
12951
- ai = allocaddrinfo(family, type, proto, node, addr, port);
12952
- HEAPU32[out >> 2] = ai;
12953
- return 0;
12954
- }
12955
- if (flags & 4) {
12956
- return -2;
12957
- }
12958
- node = DNS.lookup_name(node);
12959
- addr = inetPton4(node);
12960
- if (family === 0) {
12961
- family = 2;
12962
- } else if (family === 10) {
12963
- addr = [0, 0, _htonl(65535), addr];
12964
- }
12965
- ai = allocaddrinfo(family, type, proto, null, addr, port);
12966
- HEAPU32[out >> 2] = ai;
12967
- return 0;
12968
- };
12969
- _getaddrinfo.sig = 'ipppp';
12970
- var _getnameinfo = (sa, salen, node, nodelen, serv, servlen, flags) => {
12971
- var info = readSockaddr(sa, salen);
12972
- if (info.errno) {
12973
- return -6;
12974
- }
12975
- var port = info.port;
12976
- var addr = info.addr;
12977
- var overflowed = false;
12978
- if (node && nodelen) {
12979
- var lookup;
12980
- if (flags & 1 || !(lookup = DNS.lookup_addr(addr))) {
12981
- if (flags & 8) {
12982
- return -2;
12983
- }
12984
- } else {
12985
- addr = lookup;
12986
- }
12987
- var numBytesWrittenExclNull = stringToUTF8(addr, node, nodelen);
12988
- if (numBytesWrittenExclNull + 1 >= nodelen) {
12989
- overflowed = true;
12990
- }
12991
- }
12992
- if (serv && servlen) {
12993
- port = '' + port;
12994
- var numBytesWrittenExclNull = stringToUTF8(port, serv, servlen);
12995
- if (numBytesWrittenExclNull + 1 >= servlen) {
12996
- overflowed = true;
12997
- }
12998
- }
12999
- if (overflowed) {
13000
- return -12;
13001
- }
13002
- return 0;
13003
- };
13004
- _getnameinfo.sig = 'ipipipii';
13005
- var Protocols = { list: [], map: {} };
13006
- var stringToAscii = (str, buffer) => {
13007
- for (var i = 0; i < str.length; ++i) {
13008
- HEAP8[buffer++] = str.charCodeAt(i);
13009
- }
13010
- HEAP8[buffer] = 0;
13011
- };
13012
- var _setprotoent = (stayopen) => {
13013
- function allocprotoent(name, proto, aliases) {
13014
- var nameBuf = _malloc(name.length + 1);
13015
- stringToAscii(name, nameBuf);
13016
- var j = 0;
13017
- var length = aliases.length;
13018
- var aliasListBuf = _malloc((length + 1) * 4);
13019
- for (var i = 0; i < length; i++, j += 4) {
13020
- var alias = aliases[i];
13021
- var aliasBuf = _malloc(alias.length + 1);
13022
- stringToAscii(alias, aliasBuf);
13023
- HEAPU32[(aliasListBuf + j) >> 2] = aliasBuf;
13024
- }
13025
- HEAPU32[(aliasListBuf + j) >> 2] = 0;
13026
- var pe = _malloc(12);
13027
- HEAPU32[pe >> 2] = nameBuf;
13028
- HEAPU32[(pe + 4) >> 2] = aliasListBuf;
13029
- HEAP32[(pe + 8) >> 2] = proto;
13030
- return pe;
13031
- }
13032
- var list = Protocols.list;
13033
- var map = Protocols.map;
13034
- if (list.length === 0) {
13035
- var entry = allocprotoent('tcp', 6, ['TCP']);
13036
- list.push(entry);
13037
- map['tcp'] = map['6'] = entry;
13038
- entry = allocprotoent('udp', 17, ['UDP']);
13039
- list.push(entry);
13040
- map['udp'] = map['17'] = entry;
13041
- }
13042
- _setprotoent.index = 0;
13043
- };
13044
- _setprotoent.sig = 'vi';
13045
- var _getprotobyname = (name) => {
13046
- name = UTF8ToString(name);
13047
- _setprotoent(true);
13048
- var result = Protocols.map[name];
13049
- return result;
13050
- };
13051
- _getprotobyname.sig = 'pp';
13052
- var _getprotobynumber = (number) => {
13053
- _setprotoent(true);
13054
- var result = Protocols.map[number];
13055
- return result;
13056
- };
13057
- _getprotobynumber.sig = 'pi';
13058
- var allocateUTF8OnStack = (...args) => stringToUTF8OnStack(...args);
13059
- function _js_getpid() {
13060
- return PHPLoader.processId ?? 42;
13061
- }
13062
- function _js_wasm_trace(format, ...args) {
13063
- if (PHPLoader.trace instanceof Function) {
13064
- PHPLoader.trace(_js_getpid(), format, ...args);
13065
- }
13066
- }
13067
- var PHPWASM = {
13068
- O_APPEND: 1024,
13069
- O_NONBLOCK: 2048,
13070
- POLLHUP: 16,
13071
- SETFL_MASK: 3072,
13072
- init: function (phpWasmInitOptions) {
13073
- Module['ENV'] = Module['ENV'] || {};
13074
- Module['ENV']['PATH'] = [
13075
- Module['ENV']['PATH'],
13076
- '/internal/shared/bin',
13077
- ]
13078
- .filter(Boolean)
13079
- .join(':');
13080
- FS.mkdir('/request');
13081
- FS.mkdir('/internal');
13082
- if (phpWasmInitOptions?.nativeInternalDirPath) {
13083
- FS.mount(
13084
- FS.filesystems.NODEFS,
13085
- { root: phpWasmInitOptions.nativeInternalDirPath },
13086
- '/internal'
13087
- );
13088
- }
13089
- FS.mkdirTree('/internal/shared');
13090
- FS.mkdirTree('/internal/shared/preload');
13091
- FS.mkdirTree('/internal/shared/bin');
13092
- const originalOnRuntimeInitialized = Module['onRuntimeInitialized'];
13093
- Module['onRuntimeInitialized'] = () => {
13094
- const { node: phpBinaryNode } = FS.lookupPath(
13095
- '/internal/shared/bin/php',
13096
- { noent_okay: true }
13097
- );
13098
- if (!phpBinaryNode) {
13099
- FS.writeFile(
13100
- '/internal/shared/bin/php',
13101
- new TextEncoder().encode('#!/bin/sh\nphp "$@"')
13102
- );
13103
- FS.chmod('/internal/shared/bin/php', 493);
13104
- }
13105
- originalOnRuntimeInitialized();
13106
- };
13107
- FS.registerDevice(FS.makedev(64, 0), {
13108
- open: () => {},
13109
- close: () => {},
13110
- read: () => 0,
13111
- write: (stream, buffer, offset, length, pos) => {
13112
- const chunk = buffer.subarray(offset, offset + length);
13113
- PHPWASM.onStdout(chunk);
13114
- return length;
13115
- },
13116
- });
13117
- FS.mkdev('/request/stdout', FS.makedev(64, 0));
13118
- FS.registerDevice(FS.makedev(63, 0), {
13119
- open: () => {},
13120
- close: () => {},
13121
- read: () => 0,
13122
- write: (stream, buffer, offset, length, pos) => {
13123
- const chunk = buffer.subarray(offset, offset + length);
13124
- PHPWASM.onStderr(chunk);
13125
- return length;
13126
- },
13127
- });
13128
- FS.mkdev('/request/stderr', FS.makedev(63, 0));
13129
- FS.registerDevice(FS.makedev(62, 0), {
13130
- open: () => {},
13131
- close: () => {},
13132
- read: () => 0,
13133
- write: (stream, buffer, offset, length, pos) => {
13134
- const chunk = buffer.subarray(offset, offset + length);
13135
- PHPWASM.onHeaders(chunk);
13136
- return length;
13137
- },
13138
- });
13139
- FS.mkdev('/request/headers', FS.makedev(62, 0));
13140
- PHPWASM.EventEmitter = ENVIRONMENT_IS_NODE
13141
- ? require('events').EventEmitter
13142
- : class EventEmitter {
13143
- constructor() {
13144
- this.listeners = {};
13145
- }
13146
- emit(eventName, data) {
13147
- if (this.listeners[eventName]) {
13148
- this.listeners[eventName].forEach(
13149
- (callback) => {
13150
- callback(data);
13151
- }
13152
- );
13153
- }
13154
- }
13155
- once(eventName, callback) {
13156
- const self = this;
13157
- function removedCallback() {
13158
- callback(...arguments);
13159
- self.removeListener(eventName, removedCallback);
13160
- }
13161
- this.on(eventName, removedCallback);
13162
- }
13163
- removeAllListeners(eventName) {
13164
- if (eventName) {
13165
- delete this.listeners[eventName];
13166
- } else {
13167
- this.listeners = {};
13168
- }
13169
- }
13170
- removeListener(eventName, callback) {
13171
- if (this.listeners[eventName]) {
13172
- const idx =
13173
- this.listeners[eventName].indexOf(callback);
13174
- if (idx !== -1) {
13175
- this.listeners[eventName].splice(idx, 1);
13176
- }
13177
- }
13178
- }
13179
- };
13180
- PHPWASM.processTable = {};
13181
- PHPWASM.input_devices = {};
13182
- const originalWrite = TTY.stream_ops.write;
13183
- TTY.stream_ops.write = function (stream, ...rest) {
13184
- const retval = originalWrite(stream, ...rest);
13185
- stream.tty.ops.fsync(stream.tty);
13186
- return retval;
13187
- };
13188
- const originalPutChar = TTY.stream_ops.put_char;
13189
- TTY.stream_ops.put_char = function (tty, val) {
13190
- if (val === 10) tty.output.push(val);
13191
- return originalPutChar(tty, val);
13192
- };
13193
- },
13194
- onHeaders: function (chunk) {
13195
- if (Module['onHeaders']) {
13196
- Module['onHeaders'](chunk);
13197
- return;
13198
- }
13199
- console.log('headers', { chunk });
13200
- },
13201
- onStdout: function (chunk) {
13202
- if (Module['onStdout']) {
13203
- Module['onStdout'](chunk);
13204
- return;
13205
- }
13206
- if (ENVIRONMENT_IS_NODE) {
13207
- process.stdout.write(chunk);
13208
- } else {
13209
- console.log('stdout', { chunk });
13210
- }
13211
- },
13212
- onStderr: function (chunk) {
13213
- if (Module['onStderr']) {
13214
- Module['onStderr'](chunk);
13215
- return;
13216
- }
13217
- if (ENVIRONMENT_IS_NODE) {
13218
- process.stderr.write(chunk);
13219
- } else {
13220
- console.warn('stderr', { chunk });
13221
- }
13222
- },
13223
- getAllWebSockets: function (sock) {
13224
- const webSockets = new Set();
13225
- if (sock.server) {
13226
- sock.server.clients.forEach((ws) => {
13227
- webSockets.add(ws);
13228
- });
13229
- }
13230
- for (const peer of PHPWASM.getAllPeers(sock)) {
13231
- webSockets.add(peer.socket);
13259
+ if (type !== 0 && type !== 1 && type !== 2) {
13260
+ return -7;
13261
+ }
13262
+ if (family !== 0 && family !== 2 && family !== 10) {
13263
+ return -6;
13264
+ }
13265
+ if (service) {
13266
+ service = UTF8ToString(service);
13267
+ port = parseInt(service, 10);
13268
+ if (isNaN(port)) {
13269
+ if (flags & 1024) {
13270
+ return -2;
13271
+ }
13272
+ return -8;
13232
13273
  }
13233
- return Array.from(webSockets);
13234
- },
13235
- getAllPeers: function (sock) {
13236
- const peers = new Set();
13237
- if (sock.server) {
13238
- sock.pending
13239
- .filter((pending) => pending.peers)
13240
- .forEach((pending) => {
13241
- for (const peer of Object.values(pending.peers)) {
13242
- peers.add(peer);
13243
- }
13244
- });
13274
+ }
13275
+ if (!node) {
13276
+ if (family === 0) {
13277
+ family = 2;
13245
13278
  }
13246
- if (sock.peers) {
13247
- for (const peer of Object.values(sock.peers)) {
13248
- peers.add(peer);
13279
+ if ((flags & 1) === 0) {
13280
+ if (family === 2) {
13281
+ addr = _htonl(2130706433);
13282
+ } else {
13283
+ addr = [0, 0, 0, _htonl(1)];
13249
13284
  }
13250
13285
  }
13251
- return Array.from(peers);
13252
- },
13253
- awaitData: function (ws) {
13254
- return PHPWASM.awaitEvent(ws, 'message');
13255
- },
13256
- awaitConnection: function (ws) {
13257
- if (ws.OPEN === ws.readyState) {
13258
- return [Promise.resolve(), PHPWASM.noop];
13259
- }
13260
- return PHPWASM.awaitEvent(ws, 'open');
13261
- },
13262
- awaitClose: function (ws) {
13263
- if ([ws.CLOSING, ws.CLOSED].includes(ws.readyState)) {
13264
- return [Promise.resolve(), PHPWASM.noop];
13286
+ ai = allocaddrinfo(family, type, proto, null, addr, port);
13287
+ HEAPU32[out >> 2] = ai;
13288
+ return 0;
13289
+ }
13290
+ node = UTF8ToString(node);
13291
+ addr = inetPton4(node);
13292
+ if (addr !== null) {
13293
+ if (family === 0 || family === 2) {
13294
+ family = 2;
13295
+ } else if (family === 10 && flags & 8) {
13296
+ addr = [0, 0, _htonl(65535), addr];
13297
+ family = 10;
13298
+ } else {
13299
+ return -2;
13265
13300
  }
13266
- return PHPWASM.awaitEvent(ws, 'close');
13267
- },
13268
- awaitError: function (ws) {
13269
- if ([ws.CLOSING, ws.CLOSED].includes(ws.readyState)) {
13270
- return [Promise.resolve(), PHPWASM.noop];
13301
+ } else {
13302
+ addr = inetPton6(node);
13303
+ if (addr !== null) {
13304
+ if (family === 0 || family === 10) {
13305
+ family = 10;
13306
+ } else {
13307
+ return -2;
13308
+ }
13271
13309
  }
13272
- return PHPWASM.awaitEvent(ws, 'error');
13273
- },
13274
- awaitEvent: function (ws, event) {
13275
- let resolve;
13276
- const listener = () => {
13277
- resolve();
13278
- };
13279
- const promise = new Promise(function (_resolve) {
13280
- resolve = _resolve;
13281
- ws.once(event, listener);
13282
- });
13283
- const cancel = () => {
13284
- ws.removeListener(event, listener);
13285
- setTimeout(resolve);
13286
- };
13287
- return [promise, cancel];
13288
- },
13289
- noop: function () {},
13290
- spawnProcess: function (command, args, options) {
13291
- if (Module['spawnProcess']) {
13292
- const spawned = Module['spawnProcess'](command, args, {
13293
- ...options,
13294
- shell: true,
13295
- stdio: ['pipe', 'pipe', 'pipe'],
13296
- });
13297
- if (spawned && !('then' in spawned) && 'on' in spawned) {
13298
- return spawned;
13310
+ }
13311
+ if (addr != null) {
13312
+ ai = allocaddrinfo(family, type, proto, node, addr, port);
13313
+ HEAPU32[out >> 2] = ai;
13314
+ return 0;
13315
+ }
13316
+ if (flags & 4) {
13317
+ return -2;
13318
+ }
13319
+ node = DNS.lookup_name(node);
13320
+ addr = inetPton4(node);
13321
+ if (family === 0) {
13322
+ family = 2;
13323
+ } else if (family === 10) {
13324
+ addr = [0, 0, _htonl(65535), addr];
13325
+ }
13326
+ ai = allocaddrinfo(family, type, proto, null, addr, port);
13327
+ HEAPU32[out >> 2] = ai;
13328
+ return 0;
13329
+ };
13330
+ _getaddrinfo.sig = 'ipppp';
13331
+ var _getnameinfo = (sa, salen, node, nodelen, serv, servlen, flags) => {
13332
+ var info = readSockaddr(sa, salen);
13333
+ if (info.errno) {
13334
+ return -6;
13335
+ }
13336
+ var port = info.port;
13337
+ var addr = info.addr;
13338
+ var overflowed = false;
13339
+ if (node && nodelen) {
13340
+ var lookup;
13341
+ if (flags & 1 || !(lookup = DNS.lookup_addr(addr))) {
13342
+ if (flags & 8) {
13343
+ return -2;
13299
13344
  }
13300
- return Promise.resolve(spawned).then(function (spawned) {
13301
- if (!spawned || !spawned.on) {
13302
- throw new Error(
13303
- 'spawnProcess() must return an EventEmitter but returned a different type.'
13304
- );
13305
- }
13306
- return spawned;
13307
- });
13345
+ } else {
13346
+ addr = lookup;
13308
13347
  }
13309
- const e = new Error(
13310
- 'popen(), proc_open() etc. are unsupported on this PHP instance. Call php.setSpawnHandler() ' +
13311
- 'and provide a callback to handle spawning processes, or disable a popen(), proc_open() ' +
13312
- 'and similar functions via php.ini.'
13313
- );
13314
- e.code = 'SPAWN_UNSUPPORTED';
13315
- throw e;
13316
- },
13317
- shutdownSocket: function (socketd, how) {
13318
- const sock = getSocketFromFD(socketd);
13319
- const peer = Object.values(sock.peers)[0];
13320
- if (!peer) {
13321
- return -1;
13348
+ var numBytesWrittenExclNull = stringToUTF8(addr, node, nodelen);
13349
+ if (numBytesWrittenExclNull + 1 >= nodelen) {
13350
+ overflowed = true;
13322
13351
  }
13323
- try {
13324
- peer.socket.close();
13325
- SOCKFS.websocket_sock_ops.removePeer(sock, peer);
13326
- return 0;
13327
- } catch (e) {
13328
- console.log('Socket shutdown error', e);
13329
- return -1;
13352
+ }
13353
+ if (serv && servlen) {
13354
+ port = '' + port;
13355
+ var numBytesWrittenExclNull = stringToUTF8(port, serv, servlen);
13356
+ if (numBytesWrittenExclNull + 1 >= servlen) {
13357
+ overflowed = true;
13330
13358
  }
13331
- },
13359
+ }
13360
+ if (overflowed) {
13361
+ return -12;
13362
+ }
13363
+ return 0;
13364
+ };
13365
+ _getnameinfo.sig = 'ipipipii';
13366
+ var Protocols = { list: [], map: {} };
13367
+ var stringToAscii = (str, buffer) => {
13368
+ for (var i = 0; i < str.length; ++i) {
13369
+ HEAP8[buffer++] = str.charCodeAt(i);
13370
+ }
13371
+ HEAP8[buffer] = 0;
13372
+ };
13373
+ var _setprotoent = (stayopen) => {
13374
+ function allocprotoent(name, proto, aliases) {
13375
+ var nameBuf = _malloc(name.length + 1);
13376
+ stringToAscii(name, nameBuf);
13377
+ var j = 0;
13378
+ var length = aliases.length;
13379
+ var aliasListBuf = _malloc((length + 1) * 4);
13380
+ for (var i = 0; i < length; i++, j += 4) {
13381
+ var alias = aliases[i];
13382
+ var aliasBuf = _malloc(alias.length + 1);
13383
+ stringToAscii(alias, aliasBuf);
13384
+ HEAPU32[(aliasListBuf + j) >> 2] = aliasBuf;
13385
+ }
13386
+ HEAPU32[(aliasListBuf + j) >> 2] = 0;
13387
+ var pe = _malloc(12);
13388
+ HEAPU32[pe >> 2] = nameBuf;
13389
+ HEAPU32[(pe + 4) >> 2] = aliasListBuf;
13390
+ HEAP32[(pe + 8) >> 2] = proto;
13391
+ return pe;
13392
+ }
13393
+ var list = Protocols.list;
13394
+ var map = Protocols.map;
13395
+ if (list.length === 0) {
13396
+ var entry = allocprotoent('tcp', 6, ['TCP']);
13397
+ list.push(entry);
13398
+ map['tcp'] = map['6'] = entry;
13399
+ entry = allocprotoent('udp', 17, ['UDP']);
13400
+ list.push(entry);
13401
+ map['udp'] = map['17'] = entry;
13402
+ }
13403
+ _setprotoent.index = 0;
13404
+ };
13405
+ _setprotoent.sig = 'vi';
13406
+ var _getprotobyname = (name) => {
13407
+ name = UTF8ToString(name);
13408
+ _setprotoent(true);
13409
+ var result = Protocols.map[name];
13410
+ return result;
13332
13411
  };
13412
+ _getprotobyname.sig = 'pp';
13413
+ var _getprotobynumber = (number) => {
13414
+ _setprotoent(true);
13415
+ var result = Protocols.map[number];
13416
+ return result;
13417
+ };
13418
+ _getprotobynumber.sig = 'pi';
13333
13419
  function _js_open_process(
13334
13420
  command,
13335
13421
  argsPtr,
@@ -13909,17 +13995,25 @@ export function init(RuntimeName, PHPLoader) {
13909
13995
  const optionValue = HEAPU8[optionValuePtr];
13910
13996
  const SOL_SOCKET = 1;
13911
13997
  const SO_KEEPALIVE = 9;
13998
+ const SO_RCVTIMEO = 66;
13999
+ const SO_SNDTIMEO = 67;
13912
14000
  const IPPROTO_TCP = 6;
13913
14001
  const TCP_NODELAY = 1;
13914
- const isSupported =
14002
+ const isForwardable =
13915
14003
  (level === SOL_SOCKET && optionName === SO_KEEPALIVE) ||
13916
14004
  (level === IPPROTO_TCP && optionName === TCP_NODELAY);
13917
- if (!isSupported) {
14005
+ const isIgnorable =
14006
+ level === SOL_SOCKET &&
14007
+ (optionName === SO_RCVTIMEO || optionName === SO_SNDTIMEO);
14008
+ if (!isForwardable && !isIgnorable) {
13918
14009
  console.warn(
13919
14010
  `Unsupported socket option: ${level}, ${optionName}, ${optionValue}`
13920
14011
  );
13921
14012
  return -1;
13922
14013
  }
14014
+ if (isIgnorable) {
14015
+ return 0;
14016
+ }
13923
14017
  const ws = PHPWASM.getAllWebSockets(socketd)[0];
13924
14018
  if (!ws) {
13925
14019
  return -1;
@@ -13940,7 +14034,7 @@ export function init(RuntimeName, PHPLoader) {
13940
14034
  var Asyncify = {
13941
14035
  instrumentWasmImports(imports) {
13942
14036
  var importPattern =
13943
- /^(invoke_i|invoke_ii|invoke_iii|invoke_iiii|invoke_iiiii|invoke_iiiiii|invoke_iiiiiii|invoke_iiiiiiii|invoke_iiiiiiiii|invoke_iiiiiiiiii|invoke_v|invoke_vi|invoke_vii|invoke_viidii|invoke_viii|invoke_viiii|invoke_viiiii|invoke_viiiiii|invoke_viiiiiii|invoke_viiiiiiiii|invoke_i|invoke_ii|invoke_iii|invoke_iiii|invoke_iiiii|invoke_iiiiii|invoke_iiiiiii|invoke_iiiiiiii|invoke_iiiiiiiiii|invoke_iij|invoke_iiji|invoke_iiij|invoke_iijii|invoke_iijiji|invoke_jii|invoke_jiii|invoke_viijii|invoke_vji|js_open_process|_js_open_process|_asyncjs__js_open_process|js_popen_to_file|_js_popen_to_file|_asyncjs__js_popen_to_file|__syscall_fcntl64|___syscall_fcntl64|_asyncjs___syscall_fcntl64|js_release_file_locks|_js_release_file_locks|_async_js_release_file_locks|js_flock|_js_flock|_async_js_flock|js_fd_read|_js_fd_read|fd_close|_fd_close|_asyncjs__fd_close|close|_close|js_module_onMessage|zend_hash_str_find|_js_module_onMessage|_asyncjs__js_module_onMessage|js_waitpid|_js_waitpid|_asyncjs__js_waitpid|wasm_poll_socket|_wasm_poll_socket|_asyncjs__wasm_poll_socket|_wasm_shutdown|_asyncjs__wasm_shutdown|__asyncjs__.*)$/;
14037
+ /^(invoke_i|invoke_ii|invoke_iii|invoke_iiii|invoke_iiiii|invoke_iiiiii|invoke_iiiiiii|invoke_iiiiiiii|invoke_iiiiiiiii|invoke_iiiiiiiiii|invoke_v|invoke_vi|invoke_vii|invoke_viidii|invoke_viii|invoke_viiii|invoke_viiiii|invoke_viiiiii|invoke_viiiiiii|invoke_viiiiiiiii|invoke_i|invoke_ii|invoke_iii|invoke_iiii|invoke_iiiii|invoke_iiiiii|invoke_iiiiiii|invoke_iiiiiiii|invoke_iiiiiiiiii|invoke_iij|invoke_iiji|invoke_iiij|invoke_iijii|invoke_iijiji|invoke_jii|invoke_jiii|invoke_viijii|invoke_vji|js_open_process|_js_open_process|_asyncjs__js_open_process|js_popen_to_file|_js_popen_to_file|_asyncjs__js_popen_to_file|__syscall_fcntl64|___syscall_fcntl64|_asyncjs___syscall_fcntl64|js_release_file_locks|_js_release_file_locks|_async_js_release_file_locks|js_flock|_js_flock|_async_js_flock|js_fd_read|_js_fd_read|fd_close|_fd_close|_asyncjs__fd_close|close|_close|js_module_onMessage|zend_hash_str_find|_js_module_onMessage|_asyncjs__js_module_onMessage|js_waitpid|_js_waitpid|_asyncjs__js_waitpid|wasm_poll_socket|_wasm_poll_socket|_asyncjs__wasm_poll_socket|_wasm_shutdown|_asyncjs__wasm_shutdown|recv|_recv|setsockopt|_setsockopt|wasm_connect|_wasm_connect|__asyncjs__.*)$/;
13944
14038
  for (let [x, original] of Object.entries(imports)) {
13945
14039
  if (typeof original == 'function') {
13946
14040
  let isAsyncifyImport =
@@ -24338,6 +24432,24 @@ export function init(RuntimeName, PHPLoader) {
24338
24432
  poll();
24339
24433
  });
24340
24434
  };
24435
+ function _recv(sockfd, buffer, size, flags) {
24436
+ return _wasm_recv(sockfd, buffer, size, flags);
24437
+ }
24438
+ function _setsockopt(
24439
+ socketd,
24440
+ level,
24441
+ optionName,
24442
+ optionValuePtr,
24443
+ optionLen
24444
+ ) {
24445
+ return _wasm_setsockopt(
24446
+ socketd,
24447
+ level,
24448
+ optionName,
24449
+ optionValuePtr,
24450
+ optionLen
24451
+ );
24452
+ }
24341
24453
  var _getcontext = () => abort('missing function: ${name}');
24342
24454
  var _makecontext = () => abort('missing function: ${name}');
24343
24455
  var _swapcontext = () => abort('missing function: ${name}');
@@ -24620,6 +24732,7 @@ export function init(RuntimeName, PHPLoader) {
24620
24732
  FS.createPreloadedFile = FS_createPreloadedFile;
24621
24733
  FS.preloadFile = FS_preloadFile;
24622
24734
  FS.staticInit();
24735
+ PHPWASM.init(PHPLoader?.phpWasmInitOptions);
24623
24736
  Module['requestAnimationFrame'] = MainLoop.requestAnimationFrame;
24624
24737
  Module['pauseMainLoop'] = MainLoop.pause;
24625
24738
  Module['resumeMainLoop'] = MainLoop.resume;
@@ -24637,7 +24750,6 @@ export function init(RuntimeName, PHPLoader) {
24637
24750
  i
24638
24751
  );
24639
24752
  }
24640
- PHPWASM.init(PHPLoader?.phpWasmInitOptions);
24641
24753
  if (globalThis.setImmediate) {
24642
24754
  emSetImmediate = setImmediateWrapped;
24643
24755
  emClearImmediate = clearImmediateWrapped;
@@ -24689,6 +24801,9 @@ export function init(RuntimeName, PHPLoader) {
24689
24801
  Module['addRunDependency'] = addRunDependency;
24690
24802
  Module['removeRunDependency'] = removeRunDependency;
24691
24803
  Module['ccall'] = ccall;
24804
+ Module['UTF8ToString'] = UTF8ToString;
24805
+ Module['stringToUTF8'] = stringToUTF8;
24806
+ Module['lengthBytesUTF8'] = lengthBytesUTF8;
24692
24807
  Module['FS_preloadFile'] = FS_preloadFile;
24693
24808
  Module['FS_unlink'] = FS_unlink;
24694
24809
  Module['FS_createPath'] = FS_createPath;
@@ -24711,6 +24826,8 @@ export function init(RuntimeName, PHPLoader) {
24711
24826
  Module['___cxa_rethrow_primary_exception'] =
24712
24827
  ___cxa_rethrow_primary_exception;
24713
24828
  Module['___syscall_shutdown'] = ___syscall_shutdown;
24829
+ Module['_recv'] = _recv;
24830
+ Module['_setsockopt'] = _setsockopt;
24714
24831
  var ASM_CONSTS = {
24715
24832
  12292625: ($0) => {
24716
24833
  if (!$0) {
@@ -26540,9 +26657,14 @@ export function init(RuntimeName, PHPLoader) {
26540
26657
  uuid_unparse_upper: _uuid_unparse_upper,
26541
26658
  uuid_variant: _uuid_variant,
26542
26659
  wasm_close: _wasm_close,
26660
+ wasm_connect: _wasm_connect,
26543
26661
  wasm_poll_socket,
26544
26662
  wasm_recv: _wasm_recv,
26663
+ /** */
26664
+ recv: _recv,
26545
26665
  wasm_setsockopt: _wasm_setsockopt,
26666
+ /** */
26667
+ setsockopt: _setsockopt,
26546
26668
  wasm_shutdown: _wasm_shutdown,
26547
26669
  zoomSurface: _zoomSurface,
26548
26670
  };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@php-wasm/web-8-0",
3
- "version": "3.0.44",
3
+ "version": "3.0.46",
4
4
  "description": "PHP 8.0 WebAssembly binaries for web",
5
5
  "repository": {
6
6
  "type": "git",
@@ -35,11 +35,11 @@
35
35
  "node": ">=20.18.3",
36
36
  "npm": ">=10.1.0"
37
37
  },
38
- "gitHead": "16881b9b024e961a5254be5b366fad096585c310",
38
+ "gitHead": "845cbc01dba047db8bf0b4ae2670b924e3517087",
39
39
  "dependencies": {
40
40
  "ini": "4.1.2",
41
41
  "wasm-feature-detect": "1.8.0",
42
- "@php-wasm/universal": "3.0.44"
42
+ "@php-wasm/universal": "3.0.46"
43
43
  },
44
44
  "packageManager": "npm@10.9.2",
45
45
  "overrides": {