forks
/
arsd
mirror of https://github.com/adamdruppe/arsd.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into pixmappaint

This commit is contained in:
Elias Batek 2024-05-24 05:00:51 +02:00
parent 6072e6d8fd 709efecaf6
commit 639dede5a6
6 changed files with 310 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

155
cgi.d
View File

@ -6861,6 +6861,8 @@ version(cgi_with_websocket) {
class WebSocket {
Cgi cgi;
private bool isClient = false;
private this(Cgi cgi) {
this.cgi = cgi;
@ -6978,7 +6980,48 @@ version(cgi_with_websocket) {
string origin; /// Origin URL to send with the handshake, if desired.
string protocol; /// the protocol header, if desired.
int pingFrequency = 5000; /// Amount of time (in msecs) of idleness after which to send an automatic ping
/++
Additional headers to put in the HTTP request. These should be formatted `Name: value`, like for example:
---
Config config;
config.additionalHeaders ~= "Authorization: Bearer your_auth_token_here";
---
History:
Added February 19, 2021 (included in dub version 9.2)
+/
string[] additionalHeaders;
/++
Amount of time (in msecs) of idleness after which to send an automatic ping
Please note how this interacts with [timeoutFromInactivity] - a ping counts as activity that
keeps the socket alive.
+/
int pingFrequency = 5000;
/++
Amount of time to disconnect when there's no activity. Note that automatic pings will keep the connection alive; this timeout only occurs if there's absolutely nothing, including no responses to websocket ping frames. Since the default [pingFrequency] is only seconds, this one minute should never elapse unless the connection is actually dead.
The one thing to keep in mind is if your program is busy and doesn't check input, it might consider this a time out since there's no activity. The reason is that your program was busy rather than a connection failure, but it doesn't care. You should avoid long processing periods anyway though!
History:
Added March 31, 2021 (included in dub version 9.4)
+/
Duration timeoutFromInactivity = 1.minutes;
/++
For https connections, if this is `true`, it will fail to connect if the TLS certificate can not be
verified. Setting this to `false` will skip this check and allow the connection to continue anyway.
History:
Added April 5, 2022 (dub v10.8)
Prior to this, it always used the global (but undocumented) `defaultVerifyPeer` setting, and sometimes
even if it was true, it would skip the verification. Now, it always respects this local setting.
+/
bool verifyPeer = true;
}
/++
@ -6990,9 +7033,15 @@ version(cgi_with_websocket) {
/++
Closes the connection, sending a graceful teardown message to the other side.
Code 1000 is the normal closure code.
History:
The default `code` was changed to 1000 on January 9, 2023. Previously it was 0,
but also ignored anyway.
+/
/// Group: foundational
void close(int code = 0, string reason = null)
void close(int code = 1000, string reason = null)
//in (reason.length < 123)
in { assert(reason.length < 123); } do
{
@ -7000,31 +7049,43 @@ version(cgi_with_websocket) {
return; // it cool, we done
WebSocketFrame wss;
wss.fin = true;
wss.masked = this.isClient;
wss.opcode = WebSocketOpcode.close;
wss.data = cast(ubyte[]) reason.dup;
wss.data = [ubyte((code >> 8) & 0xff), ubyte(code & 0xff)] ~ cast(ubyte[]) reason.dup;
wss.send(&llsend);
readyState_ = CLOSING;
closeCalled = true;
llclose();
}
private bool closeCalled;
/++
Sends a ping message to the server. This is done automatically by the library if you set a non-zero [Config.pingFrequency], but you can also send extra pings explicitly as well with this function.
+/
/// Group: foundational
void ping() {
void ping(in ubyte[] data = null) {
WebSocketFrame wss;
wss.fin = true;
wss.masked = this.isClient;
wss.opcode = WebSocketOpcode.ping;
if(data !is null) wss.data = data.dup;
wss.send(&llsend);
}
// automatically handled....
void pong() {
/++
Sends a pong message to the server. This is normally done automatically in response to pings.
+/
/// Group: foundational
void pong(in ubyte[] data = null) {
WebSocketFrame wss;
wss.fin = true;
wss.masked = this.isClient;
wss.opcode = WebSocketOpcode.pong;
if(data !is null) wss.data = data.dup;
wss.send(&llsend);
}
@ -7035,6 +7096,7 @@ version(cgi_with_websocket) {
void send(in char[] textData) {
WebSocketFrame wss;
wss.fin = true;
wss.masked = this.isClient;
wss.opcode = WebSocketOpcode.text;
wss.data = cast(ubyte[]) textData.dup;
wss.send(&llsend);
@ -7046,6 +7108,7 @@ version(cgi_with_websocket) {
/// Group: foundational
void send(in ubyte[] binaryData) {
WebSocketFrame wss;
wss.masked = this.isClient;
wss.fin = true;
wss.opcode = WebSocketOpcode.binary;
wss.data = cast(ubyte[]) binaryData.dup;
@ -7080,10 +7143,12 @@ version(cgi_with_websocket) {
return false;
if(!isDataPending())
return true;
while(isDataPending()) {
if(lowLevelReceive() == false)
throw new ConnectionClosedException("Connection closed in middle of message");
}
goto checkAgain;
}
@ -7161,23 +7226,40 @@ version(cgi_with_websocket) {
}
break;
case WebSocketOpcode.close:
readyState_ = CLOSED;
//import std.stdio; writeln("closed ", cast(string) m.data);
ushort code = CloseEvent.StandardCloseCodes.noStatusCodePresent;
const(char)[] reason;
if(m.data.length >= 2) {
code = (m.data[0] << 8) | m.data[1];
reason = (cast(char[]) m.data[2 .. $]);
}
if(onclose)
onclose();
onclose(CloseEvent(code, reason, true));
// if we receive one and haven't sent one back we're supposed to echo it back and close.
if(!closeCalled)
close(code, reason.idup);
readyState_ = CLOSED;
unregisterActiveSocket(this);
break;
case WebSocketOpcode.ping:
pong();
// import std.stdio; writeln("ping received ", m.data);
pong(m.data);
break;
case WebSocketOpcode.pong:
// import std.stdio; writeln("pong received ", m.data);
// just really references it is still alive, nbd.
break;
default: // ignore though i could and perhaps should throw too
}
}
// the recv thing can be invalidated so gotta copy it over ugh
if(d.length) {
m.data = m.data.dup();
}
@ -7196,8 +7278,52 @@ version(cgi_with_websocket) {
} while(lowLevelReceive());
}
/++
Arguments for the close event. The `code` and `reason` are provided from the close message on the websocket, if they are present. The spec says code 1000 indicates a normal, default reason close, but reserves the code range from 3000-5000 for future definition; the 3000s can be registered with IANA and the 4000's are application private use. The `reason` should be user readable, but not displayed to the end user. `wasClean` is true if the server actually sent a close event, false if it just disconnected.
void delegate() onclose; ///
$(PITFALL
The `reason` argument references a temporary buffer and there's no guarantee it will remain valid once your callback returns. It may be freed and will very likely be overwritten. If you want to keep the reason beyond the callback, make sure you `.idup` it.
)
History:
Added March 19, 2023 (dub v11.0).
+/
static struct CloseEvent {
ushort code;
const(char)[] reason;
bool wasClean;
string extendedErrorInformationUnstable;
/++
See https://www.rfc-editor.org/rfc/rfc6455#section-7.4.1 for details.
+/
enum StandardCloseCodes {
purposeFulfilled = 1000,
goingAway = 1001,
protocolError = 1002,
unacceptableData = 1003, // e.g. got text message when you can only handle binary
Reserved = 1004,
noStatusCodePresent = 1005, // not set by endpoint.
abnormalClosure = 1006, // not set by endpoint. closed without a Close control. FIXME: maybe keep a copy of errno around for these
inconsistentData = 1007, // e.g. utf8 validation failed
genericPolicyViolation = 1008,
messageTooBig = 1009,
clientRequiredExtensionMissing = 1010, // only the client should send this
unnexpectedCondition = 1011,
unverifiedCertificate = 1015, // not set by client
}
}
/++
The `CloseEvent` you get references a temporary buffer that may be overwritten after your handler returns. If you want to keep it or the `event.reason` member, remember to `.idup` it.
History:
The `CloseEvent` was changed to a [arsd.core.FlexibleDelegate] on March 19, 2023 (dub v11.0). Before that, `onclose` was a public member of type `void delegate()`. This change means setters still work with or without the [CloseEvent] argument.
Your onclose method is now also called on abnormal terminations. Check the `wasClean` member of the `CloseEvent` to know if it came from a close frame or other cause.
+/
arsd.core.FlexibleDelegate!(void delegate(CloseEvent event)) onclose;
void delegate() onerror; ///
void delegate(in char[]) ontextmessage; ///
void delegate(in ubyte[]) onbinarymessage; ///
@ -7216,7 +7342,8 @@ version(cgi_with_websocket) {
onbinarymessage = dg;
}
/* } end copy/paste */
/* } end copy/paste */
}
@ -7262,7 +7389,9 @@ version(cgi_with_websocket) {
cgi.flush();
return new WebSocket(cgi);
auto ws = new WebSocket(cgi);
ws.readyState_ = WebSocket.OPEN;
return ws;
}
// FIXME get websocket to work on other modes, not just embedded_httpd

23
com.d
View File

@ -250,11 +250,11 @@ struct ComResult {
T getD(T)() {
switch(result.vt) {
case 3: // int
case VARENUM.VT_I4: // int
static if(is(T : const long))
return result.intVal;
throw new Exception("cannot convert variant of type int to requested " ~ T.stringof);
case 8: // string
case VARENUM.VT_BSTR:
static if(is(T : const string))
return makeUtf8StringFromWindowsString(result.bstrVal); // FIXME free?
throw new Exception("cannot convert variant of type string to requested " ~ T.stringof);
@ -720,7 +720,6 @@ auto getComObject(T = Dynamic)(wstring c, bool tryCreateIfGetFails = true) {
// FIXME: add one to get by ProgID rather than always guid
// FIXME: add a dynamic com object that uses IDispatch
/* COM SERVER CODE */
T getFromVariant(T)(VARIANT arg) {
@ -729,25 +728,31 @@ T getFromVariant(T)(VARIANT arg) {
static if(is(T == void)) {
return;
} else static if(is(T == int)) {
if(arg.vt == 3)
if(arg.vt == VARENUM.VT_I4)
return arg.intVal;
} else static if (is(T == float)) {
if(arg.vt == VARENUM.VT_R4)
return arg.fltVal;
} else static if (is(T == double)) {
if(arg.vt == VARENUM.VT_R8)
return arg.dblVal;
} else static if(is(T == bool)) {
if(arg.vt == 11)
if(arg.vt == VARENUM.VT_BOOL)
return arg.boolVal ? true : false;
} else static if(is(T == string)) {
if(arg.vt == 8) {
if(arg.vt == VARENUM.VT_BSTR) {
auto str = arg.bstrVal;
scope(exit) SysFreeString(str);
return to!string(str[0 .. SysStringLen(str)]);
}
} else static if(is(T == IDispatch)) {
if(arg.vt == 9)
if(arg.vt == VARENUM.VT_DISPATCH)
return arg.pdispVal;
} else static if(is(T : IUnknown)) {
// if(arg.vt == 13)
static assert(0);
} else static if(is(T == ComClient!(D, I), D, I)) {
if(arg.vt == 9)
if(arg.vt == VARENUM.VT_DISPATCH)
return ComClient!(D, I)(arg.pdispVal);
} else static if(is(T == E[], E)) {
if(arg.vt & 0x2000) {
@ -789,7 +794,7 @@ T getFromVariant(T)(VARIANT arg) {
}
}
}
throw new Exception("Type mismatch, needed "~ T.stringof ~"got " ~ to!string(arg.vt));
throw new Exception("Type mismatch, needed "~ T.stringof ~" got " ~ to!string(cast(VARENUM) arg.vt));
assert(0);
}

26
core.d
View File

@ -42,6 +42,12 @@ static if(__traits(compiles, () { import core.interpolation; })) {
struct InterpolatedExpression(string code) {}
}
import core.attribute;
static if(__traits(hasMember, core.attribute, "implicit"))
alias implicit = core.attribute.implicit;
else
enum implicit;
// FIXME: add callbacks on file open for tracing dependencies dynamically
@ -130,6 +136,8 @@ version(Windows) {
import core.sys.freebsd.sys.event;
// the version in druntime doesn't have the default arg making it a pain to use when the freebsd
// version adds a new field
extern(D) void EV_SET(kevent_t* kevp, typeof(kevent_t.tupleof) args = kevent_t.tupleof.init)
{
*kevp = kevent_t(args);
@ -3982,6 +3990,10 @@ package(arsd) int indexOf(scope const(char)[] haystack, scope const(char)[] need
return -1;
}
package(arsd) int indexOf(scope const(ubyte)[] haystack, scope const(char)[] needle) {
return indexOf(cast(const(char)[]) haystack, needle);
}
unittest {
assert("foo".indexOf("f") == 0);
assert("foo".indexOf("o") == 1);
@ -4585,13 +4597,13 @@ class AsyncReadResponse : AsyncOperationResponse {
runHelperFunction() - whomever it reports to is the parent
+/
version(HasThread) class ScheduableTask : Fiber {
version(HasThread) class SchedulableTask : Fiber {
private void delegate() dg;
// linked list stuff
private static ScheduableTask taskRoot;
private ScheduableTask previous;
private ScheduableTask next;
private static SchedulableTask taskRoot;
private SchedulableTask previous;
private SchedulableTask next;
// need the controlling thread to know how to wake it up if it receives a message
private Thread controllingThread;
@ -4680,7 +4692,7 @@ version(HasThread) SchedulableTaskController inSchedulableTask() {
import core.thread.fiber;
if(auto fiber = Fiber.getThis) {
return SchedulableTaskController(cast(ScheduableTask) fiber);
return SchedulableTaskController(cast(SchedulableTask) fiber);
}
return SchedulableTaskController(null);
@ -4688,11 +4700,11 @@ version(HasThread) SchedulableTaskController inSchedulableTask() {
/// ditto
version(HasThread) struct SchedulableTaskController {
private this(ScheduableTask fiber) {
private this(SchedulableTask fiber) {
this.fiber = fiber;
}
private ScheduableTask fiber;
private SchedulableTask fiber;
/++

16
email.d
View File

@ -78,13 +78,13 @@ class EmailMessage {
string[] headers;
/** If you use the send method with an SMTP server, you don't want to change this.
*
* While RFC 2045 mandates CRLF as a lineseperator, there are some edge-cases where this won't work.
* When passing the E-Mail string to a unix program which handles communication with the SMTP server, some (i.e. qmail)
* expect the system lineseperator (LF) instead.
* Notably, the google mail REST API will choke on CRLF lineseps and produce strange emails (as of 2024).
*/
/++
If you use the send method with an SMTP server, you don't want to change this.
While RFC 2045 mandates CRLF as a lineseperator, there are some edge-cases where this won't work.
When passing the E-Mail string to a unix program which handles communication with the SMTP server, some (i.e. qmail)
expect the system lineseperator (LF) instead.
Notably, the google mail REST API will choke on CRLF lineseps and produce strange emails (as of 2024).
+/
string linesep = "\r\n";
private bool isMime = false;
@ -1219,7 +1219,7 @@ unittest {
mail.setTextBody(text);
mail.addAttachment("text/plain", "attachment.txt", text.representation);
// In case binary and plaintext get handled differently one day
mail.addAttachment("application/octet-stream", "attachment.bin", text.representation);
mail.addAttachment("application/octet-stream", "attachment.bin", text.representation);
auto result = new IncomingEmailMessage(mail.toString().split("\r\n"));

206
http2.d
View File

@ -4094,6 +4094,7 @@ class HttpApiClient() {
string urlBase;
string oauth2Token;
string submittedContentType;
string authType = "Bearer";
/++
Params:
@ -4161,7 +4162,7 @@ class HttpApiClient() {
auto req = httpClient.navigateTo(u, requestMethod);
if(oauth2Token.length)
req.requestParameters.headers ~= "Authorization: Bearer " ~ oauth2Token;
req.requestParameters.headers ~= "Authorization: "~ authType ~" " ~ oauth2Token;
req.requestParameters.contentType = submittedContentType;
req.requestParameters.bodyData = bodyBytes;
@ -4911,6 +4912,8 @@ class WebSocket {
while(d.length) {
auto r = socket.send(d);
if(r < 0 && wouldHaveBlocked()) {
// FIXME: i should register for a write wakeup
version(use_arsd_core) assert(0);
import core.thread;
Thread.sleep(1.msecs);
continue;
@ -4954,7 +4957,7 @@ class WebSocket {
return true;
if(r <= 0) {
//import std.stdio; writeln(WSAGetLastError());
throw new Exception("Socket receive failed");
throw new Exception("Socket receive failed " ~ lastSocketError());
}
receiveBufferUsedLength += r;
return true;
@ -5365,6 +5368,59 @@ class WebSocket {
/* } end copy/paste */
// returns true if still active
private static bool readyToRead(WebSocket sock) {
sock.timeoutFromInactivity = MonoTime.currTime + sock.config.timeoutFromInactivity;
if(!sock.lowLevelReceive()) {
sock.readyState_ = CLOSED;
if(sock.onerror)
sock.onerror();
if(sock.onclose)
sock.onclose(CloseEvent(CloseEvent.StandardCloseCodes.abnormalClosure, "Connection lost", false, lastSocketError()));
unregisterActiveSocket(sock);
return false;
}
while(sock.processOnce().populated) {}
return true;
}
// returns true if still active, false if not
private static bool timeoutAndPingCheck(WebSocket sock, MonoTime now, Duration* minimumTimeoutForSelect) {
auto diff = sock.timeoutFromInactivity - now;
if(diff <= 0.msecs) {
// it timed out
if(sock.onerror)
sock.onerror();
if(sock.onclose)
sock.onclose(CloseEvent(CloseEvent.StandardCloseCodes.abnormalClosure, "Connection timed out", false, null));
sock.socket.close();
sock.readyState_ = CLOSED;
unregisterActiveSocket(sock);
return false;
}
if(minimumTimeoutForSelect && diff < *minimumTimeoutForSelect)
*minimumTimeoutForSelect = diff;
diff = sock.nextPing - now;
if(diff <= 0.msecs) {
//sock.send(`{"action": "ping"}`);
sock.ping();
sock.nextPing = now + sock.config.pingFrequency.msecs;
} else {
if(minimumTimeoutForSelect && diff < *minimumTimeoutForSelect)
*minimumTimeoutForSelect = diff;
}
return true;
}
/*
const int bufferedAmount // amount pending
const string extensions
@ -5394,87 +5450,56 @@ class WebSocket {
loopExited = false; // reset it so we can reenter
}
static SocketSet readSet;
version(use_arsd_core) {
loopExited = false;
if(readSet is null)
readSet = new SocketSet();
import arsd.core;
getThisThreadEventLoop().run(() => WebSocket.activeSockets.length == 0 || loopExited || (localLoopExited !is null && *localLoopExited == true));
} else {
static SocketSet readSet;
loopExited = false;
if(readSet is null)
readSet = new SocketSet();
outermost: while(!loopExited && (localLoopExited is null || (*localLoopExited == false))) {
readSet.reset();
loopExited = false;
Duration timeout = 3.seconds;
outermost: while(!loopExited && (localLoopExited is null || (*localLoopExited == false))) {
readSet.reset();
auto now = MonoTime.currTime;
bool hadAny;
foreach(sock; activeSockets) {
auto diff = sock.timeoutFromInactivity - now;
if(diff <= 0.msecs) {
// timeout
if(sock.onerror)
sock.onerror();
Duration timeout = 3.seconds;
if(sock.onclose)
sock.onclose(CloseEvent(CloseEvent.StandardCloseCodes.abnormalClosure, "Connection timed out", false, null));
sock.socket.close();
sock.readyState_ = CLOSED;
unregisterActiveSocket(sock);
continue outermost;
}
if(diff < timeout)
timeout = diff;
diff = sock.nextPing - now;
if(diff <= 0.msecs) {
//sock.send(`{"action": "ping"}`);
sock.ping();
sock.nextPing = now + sock.config.pingFrequency.msecs;
} else {
if(diff < timeout)
timeout = diff;
}
readSet.add(sock.socket);
hadAny = true;
}
if(!hadAny) {
// import std.stdio; writeln("had none");
return;
}
tryAgain:
// import std.stdio; writeln(timeout);
auto selectGot = Socket.select(readSet, null, null, timeout);
if(selectGot == 0) { /* timeout */
// timeout
continue; // it will be handled at the top of the loop
} else if(selectGot == -1) { /* interrupted */
goto tryAgain;
} else {
auto now = MonoTime.currTime;
bool hadAny;
foreach(sock; activeSockets) {
if(readSet.isSet(sock.socket)) {
sock.timeoutFromInactivity = MonoTime.currTime + sock.config.timeoutFromInactivity;
if(!sock.lowLevelReceive()) {
sock.readyState_ = CLOSED;
if(!timeoutAndPingCheck(sock, now, &timeout))
continue outermost;
if(sock.onerror)
sock.onerror();
readSet.add(sock.socket);
hadAny = true;
}
if(sock.onclose)
sock.onclose(CloseEvent(CloseEvent.StandardCloseCodes.abnormalClosure, "Connection lost", false, lastSocketError()));
if(!hadAny) {
// import std.stdio; writeln("had none");
return;
}
unregisterActiveSocket(sock);
continue outermost;
tryAgain:
// import std.stdio; writeln(timeout);
auto selectGot = Socket.select(readSet, null, null, timeout);
if(selectGot == 0) { /* timeout */
// timeout
continue; // it will be handled at the top of the loop
} else if(selectGot == -1) { /* interrupted */
goto tryAgain;
} else {
foreach(sock; activeSockets) {
if(readSet.isSet(sock.socket)) {
if(!readyToRead(sock))
continue outermost;
selectGot--;
if(selectGot <= 0)
break;
}
while(sock.processOnce().populated) {}
selectGot--;
if(selectGot <= 0)
break;
}
}
}
@ -5501,20 +5526,37 @@ class WebSocket {
void registerActiveSocket(WebSocket s) {
// ensure it isn't already there...
assert(s !is null);
foreach(i, a; activeSockets)
if(a is s)
return;
if(s.registered)
return;
s.activeSocketArrayIndex = activeSockets.length;
activeSockets ~= s;
s.registered = true;
version(use_arsd_core) {
s.unregisterToken = arsd.core.getThisThreadEventLoop().addCallbackOnFdReadable(s.socket.handle, new arsd.core.CallbackHelper(() { s.readyToRead(s); }));
}
}
void unregisterActiveSocket(WebSocket s) {
foreach(i, a; activeSockets)
if(s is a) {
activeSockets[i] = activeSockets[$-1];
activeSockets = activeSockets[0 .. $-1];
break;
}
version(use_arsd_core) {
s.unregisterToken.unregister();
}
auto i = s.activeSocketArrayIndex;
assert(activeSockets[i] is s);
activeSockets[i] = activeSockets[$-1];
activeSockets[i].activeSocketArrayIndex = i;
activeSockets = activeSockets[0 .. $-1];
activeSockets.assumeSafeAppend();
s.registered = false;
}
}
private bool registered;
private size_t activeSocketArrayIndex;
version(use_arsd_core) {
static import arsd.core;
arsd.core.ICoreEventLoop.UnregisterToken unregisterToken;
}
}
private template imported(string mod) {
@ -5527,6 +5569,8 @@ private template imported(string mod) {
template addToSimpledisplayEventLoop() {
import arsd.simpledisplay;
void addToSimpledisplayEventLoop(WebSocket ws, imported!"arsd.simpledisplay".SimpleWindow window) {
version(use_arsd_core)
return; // already done implicitly
version(Windows)
auto event = WSACreateEvent();

2
stb_truetype.d
View File

@ -13,6 +13,8 @@
// here's some D convenience functions
module stb_truetype;
@system:
struct TtfFont {
stbtt_fontinfo font;
this(in ubyte[] data) {