chaos/QuasselClient
1
0
Fork 0
Code Issues Releases Activity

Rename a bunch o things.

Browse source
This commit is contained in:
Kitteh 2021-06-02 19:39:17 +01:00
parent fbb68deb7f
commit 2ac78e21e6
4 changed files with 192 additions and 171 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
src/client.zig
View file

@ -22,11 +22,11 @@ pub const Client = struct {
pub fn handshake(s: *Client) !void {
const magic = 0x42b33f00;
try write.add_int(s.stream.writer(), magic);
try write.add_int(s.stream.writer(), 0x80000002);
var flags = try read.get_byte(s.stream.reader());
var extra = try read.get_short(s.stream.reader());
var version = try read.get_signed_byte(s.stream.reader());
try write.writeUInt(s.stream.writer(), magic);
try write.writeUInt(s.stream.writer(), 0x80000002);
var flags = try read.readByte(s.stream.reader());
var extra = try read.readShort(s.stream.reader());
var version = try read.readSignedByte(s.stream.reader());
std.debug.print("Handshake: flags={d} extra={d} version={d} \n", .{ flags, extra, version });
}
@ -35,31 +35,26 @@ pub const Client = struct {
var map = std.StringHashMap(qvar.QVariant).init(s.allocator);
try map.put("MsgType", .{ .string = "ClientInit" });
try map.put("ProtocolVersion", .{ .int = 10 });
try map.put("ClientVersion", .{ .string = "0.1 (quasselclient)" });
try map.put("ClientDate", .{ .string = "Wed, 02 Jun 2021 17:30:30 +0100" });
try map.put("Features", .{ .int = 0 });
try map.put("MsgType", .{ .String = "ClientInit" });
try map.put("ProtocolVersion", .{ .UInt = 10 });
try map.put("ClientVersion", .{ .String = "0.1 (quasselclient)" });
try map.put("ClientDate", .{ .String = "Wed, 02 Jun 2021 17:30:30 +0100" });
try map.put("Features", .{ .Int = 0 });
var empty = std.ArrayList([]const u8).init(s.allocator);
try map.put("FeatureList", .{ .stringlist = empty });
try map.put("FeatureList", .{ .QStringList = empty });
try write.add_message(list.writer(), s.allocator, map);
try write.writeFrame(list.writer(), s.allocator, map);
try dumpDebug("ClientInit.bin", list);
try s.stream.writer().writeAll(list.items);
std.debug.print("\n\nInitPacket: \n", .{});
qvar.pretty_print_variant(.{.qmap = map}, 0);
var size = read.get_int(s.stream.reader());
//std.debug.print("InitResp: size={d} \n", .{size});
qvar.pretty_print_variant(.{.QVariantMap = map}, 0);
var size = read.readUInt(s.stream.reader());
std.debug.print("\n\nInitResponse: \n", .{});
var varient = try read.get_variant(s.stream.reader(), s.allocator);
var varient = try read.readQVariant(s.stream.reader(), s.allocator);
qvar.pretty_print_variant(varient, 0);
//std.debug.print("InitResp: type={s} \n", .{varient.qmap.get("MsgType").?.string});
}
pub fn quassel_login(s: *Client, username: []const u8, password: []const u8) !void {
@ -67,11 +62,11 @@ pub const Client = struct {
var map = std.StringHashMap(qvar.QVariant).init(s.allocator);
try map.put("MsgType", .{ .string = "ClientLogin" });
try map.put("User", .{ .string = username });
try map.put("Password", .{ .string = password });
try map.put("MsgType", .{ .String = "ClientLogin" });
try map.put("User", .{ .String = username });
try map.put("Password", .{ .String = password });
try write.add_message(list.writer(), s.allocator, map);
try write.writeFrame(list.writer(), s.allocator, map);
try dumpDebug("ClientLogin.bin", list);
try s.stream.writer().writeAll(list.items);

104
src/qtshit/qvariant.zig
View file

@ -2,58 +2,57 @@ const std = @import("std");
const range = @import("./rangeiter.zig").range;
pub const QVariant = union(enum) {
int: u32,
short: u16,
byte: u8,
bytearray: std.ArrayList(u8),
string: []const u8,
stringlist: std.ArrayList([]const u8),
qmap: std.StringHashMap(QVariant),
qvarlist: std.ArrayList(QVariant),
empty: bool,
Int: i32,
UInt: u32,
Short: u16,
Byte: u8,
String: []const u8,
QByteArray: std.ArrayList(u8),
QStringList: std.ArrayList([]const u8),
QVariantMap: std.StringHashMap(QVariant),
QVariantList: std.ArrayList(QVariant),
};
pub const QVariantTypes = enum(u32) {
byte = 1,
// IDK why there is 2???
int_1 = 2,
int_2 = 3,
qmap = 8,
qvarlist = 9,
string = 10,
stringlist = 11,
bytearray = 12,
short = 133,
Byte = 1,
Int = 2,
UInt = 3,
QVariantMap = 8,
QVariantList = 9,
String = 10,
QStringList = 11,
QByteArray = 12,
Short = 133,
};
pub fn qvariant_type_id(variant: QVariant) !u32 {
switch (variant) {
.byte => {
return @enumToInt(QVariantTypes.byte);
.Byte => {
return @enumToInt(QVariantTypes.Byte);
},
.int => {
return @enumToInt(QVariantTypes.int_2);
.Int => {
return @enumToInt(QVariantTypes.Int);
},
.qmap => {
return @enumToInt(QVariantTypes.qmap);
.UInt => {
return @enumToInt(QVariantTypes.UInt);
},
.qvarlist => {
return @enumToInt(QVariantTypes.qvarlist);
.QVariantMap => {
return @enumToInt(QVariantTypes.QVariantMap);
},
.string => {
return @enumToInt(QVariantTypes.string);
.QVariantList => {
return @enumToInt(QVariantTypes.QVariantList);
},
.stringlist => {
return @enumToInt(QVariantTypes.stringlist);
.String => {
return @enumToInt(QVariantTypes.String);
},
.bytearray => {
return @enumToInt(QVariantTypes.bytearray);
.QStringList => {
return @enumToInt(QVariantTypes.QStringList);
},
.short => {
return @enumToInt(QVariantTypes.short);
.QByteArray => {
return @enumToInt(QVariantTypes.QByteArray);
},
else => {
return 0;
.Short => {
return @enumToInt(QVariantTypes.Short);
},
}
}
@ -69,14 +68,17 @@ pub fn pretty_print_variant(variant: QVariant, indentLevel: u64) void {
print_indent_level(indentLevel);
switch (variant) {
.byte => |b| {
.Byte => |b| {
std.debug.print("Byte: {d}\n", .{b});
},
.int => |i| {
.Int => |i| {
std.debug.print("Int: {d}\n", .{i});
},
.qmap => |q| {
std.debug.print("QMap:\n", .{});
.UInt => |i| {
std.debug.print("UInt: {d}\n", .{i});
},
.QVariantMap => |q| {
std.debug.print("QVariantMap:\n", .{});
var qMapIter = q.iterator();
while (qMapIter.next()) |v| {
print_indent_level(indentLevel + 1);
@ -86,8 +88,8 @@ pub fn pretty_print_variant(variant: QVariant, indentLevel: u64) void {
pretty_print_variant(v.value, indentLevel + 2);
}
},
.qvarlist => |l| {
std.debug.print("QVarList:\n", .{});
.QVariantList => |l| {
std.debug.print("QVariantList:\n", .{});
for (l.items) |varient, i| {
print_indent_level(indentLevel + 1);
@ -95,14 +97,20 @@ pub fn pretty_print_variant(variant: QVariant, indentLevel: u64) void {
pretty_print_variant(varient, indentLevel + 2);
}
},
.string => |s| {
.String => |s| {
std.debug.print("String: \"{s}\"\n", .{s});
},
.stringlist => {},
.bytearray => {},
.short => |s| {
.QStringList => |l| {
std.debug.print("QStringList:\n", .{});
for (l.items) |str, i| {
print_indent_level(indentLevel + 1);
std.debug.print("\"{s}\" \n", .{str});
}
},
.QByteArray => {},
.Short => |s| {
std.debug.print("Short: \"{d}\"\n", .{s});
},
else => {},
}
}

111
src/qtshit/read.zig
View file

@ -2,48 +2,52 @@ const std = @import("std");
const qvar = @import("./qvariant.zig");
const range = @import("./rangeiter.zig").range;
pub fn get_int(reader: anytype) !u32 {
pub fn readInt(reader: anytype) !i32 {
return try reader.readIntBig(i32);
}
pub fn readUInt(reader: anytype) !u32 {
return try reader.readIntBig(u32);
}
pub fn get_short(reader: anytype) !u16 {
pub fn readShort(reader: anytype) !u16 {
return try reader.readIntBig(u16);
}
pub fn get_byte(reader: anytype) !u8 {
pub fn readByte(reader: anytype) !u8 {
return try reader.readByte();
}
pub fn get_signed_byte(reader: anytype) !i8 {
pub fn readSignedByte(reader: anytype) !i8 {
return try reader.readIntBig(i8);
}
pub fn get_bytearray(reader: anytype, allocator: *std.mem.Allocator) !std.ArrayList(u8) {
pub fn readQByteArray(reader: anytype, allocator: *std.mem.Allocator) !std.ArrayList(u8) {
var byteList = std.ArrayList(u8).init(allocator);
var length = try get_int(reader);
var length = try readUInt(reader);
var index: usize = 0;
while (true) {
if (index == length) return byteList;
const byte = try reader.readByte();
const byte = try readByte(reader);
try byteList.append(byte);
index += 1;
}
}
pub fn get_string(reader: anytype, allocator: *std.mem.Allocator) ![]u8 {
pub fn readString(reader: anytype, allocator: *std.mem.Allocator) ![]u8 {
var data = std.ArrayList(u8).init(allocator);
defer data.deinit();
var length = try reader.readIntBig(i32);
var length = try readInt(reader);
var chars = @divTrunc(length, 2);
var index: usize = 0;
while (true) {
if (index == chars) break;
const byte = try reader.readIntBig(u16);
const byte = try readShort(reader);
try data.append(@truncate(u8, byte));
index += 1;
}
@ -56,84 +60,87 @@ pub fn get_string(reader: anytype, allocator: *std.mem.Allocator) ![]u8 {
return ut8Str;
}
pub fn get_qvarlist(reader: anytype, allocator: *std.mem.Allocator) !std.ArrayList(qvar.QVariant) {
pub fn readQVariantList(reader: anytype, allocator: *std.mem.Allocator) !std.ArrayList(qvar.QVariant) {
var varlist = std.ArrayList(qvar.QVariant).init(allocator);
var size = try get_int(reader);
var size = try readUInt(reader);
var i: u32 = 0;
while (i < size) {
try varlist.append(try get_variant(reader, allocator));
try varlist.append(try readQVariant(reader, allocator));
i = i + 1;
}
return varlist;
}
pub fn get_stringlist(reader: anytype, allocator: *std.mem.Allocator) !std.ArrayList([]const u8) {
pub fn readQStringList(reader: anytype, allocator: *std.mem.Allocator) !std.ArrayList([]const u8) {
var strList = std.ArrayList([]const u8).init(allocator);
var size = try get_int(reader);
var size = try readUInt(reader);
var i: u32 = 0;
while (i < size) {
try strList.append(try get_string(reader, allocator));
try strList.append(try readString(reader, allocator));
i = i + 1;
}
return strList;
}
pub fn get_variant_t(reader: anytype, type_id: u32, allocator: *std.mem.Allocator) (@TypeOf(reader).Error || error{EndOfStream} || error{OutOfMemory})!qvar.QVariant {
pub fn readQVariantT(reader: anytype, type_id: u32, allocator: *std.mem.Allocator) (@TypeOf(reader).Error || error{EndOfStream} || error{OutOfMemory})!qvar.QVariant {
switch (type_id) {
@enumToInt(qvar.QVariantTypes.byte) => {
var byte = try get_byte(reader);
return qvar.QVariant{ .byte = byte };
@enumToInt(qvar.QVariantTypes.Byte) => {
var byte = try readByte(reader);
return qvar.QVariant{ .Byte = byte };
},
@enumToInt(qvar.QVariantTypes.int_1), @enumToInt(qvar.QVariantTypes.int_2) => {
var int = try get_int(reader);
return qvar.QVariant{ .int = int };
@enumToInt(qvar.QVariantTypes.Int) => {
var int = try readInt(reader);
return qvar.QVariant{ .Int = int };
},
@enumToInt(qvar.QVariantTypes.qmap) => {
var map = try get_qvariantmap(reader, allocator);
return qvar.QVariant{ .qmap = map };
@enumToInt(qvar.QVariantTypes.UInt) => {
var uint = try readUInt(reader);
return qvar.QVariant{ .UInt = uint };
},
@enumToInt(qvar.QVariantTypes.qvarlist) => {
var list = try get_qvarlist(reader, allocator);
return qvar.QVariant{ .qvarlist = list };
@enumToInt(qvar.QVariantTypes.QVariantMap) => {
var map = try readQVariantMap(reader, allocator);
return qvar.QVariant{ .QVariantMap = map };
},
@enumToInt(qvar.QVariantTypes.string) => {
var str = try get_string(reader, allocator);
return qvar.QVariant{ .string = str };
@enumToInt(qvar.QVariantTypes.QVariantList) => {
var list = try readQVariantList(reader, allocator);
return qvar.QVariant{ .QVariantList = list };
},
@enumToInt(qvar.QVariantTypes.stringlist) => {
var strlist = try get_stringlist(reader, allocator);
return qvar.QVariant{ .stringlist = strlist };
@enumToInt(qvar.QVariantTypes.String) => {
var str = try readString(reader, allocator);
return qvar.QVariant{ .String = str };
},
@enumToInt(qvar.QVariantTypes.bytearray) => {
var bArray = try get_bytearray(reader, allocator);
return qvar.QVariant{ .bytearray = bArray };
@enumToInt(qvar.QVariantTypes.QStringList) => {
var strlist = try readQStringList(reader, allocator);
return qvar.QVariant{ .QStringList = strlist };
},
@enumToInt(qvar.QVariantTypes.short) => {
var short = try get_short(reader);
return qvar.QVariant{ .short = short };
@enumToInt(qvar.QVariantTypes.QByteArray) => {
var bArray = try readQByteArray(reader, allocator);
return qvar.QVariant{ .QByteArray = bArray };
},
@enumToInt(qvar.QVariantTypes.Short) => {
var short = try readShort(reader);
return qvar.QVariant{ .Short = short };
},
else => {
@panic("Unsupported!");
},
@panic("Unknown Type");
}
}
return qvar.QVariant{ .empty = true };
}
pub fn get_variant(reader: anytype, allocator: *std.mem.Allocator) !qvar.QVariant {
var type_id = try get_int(reader);
_ = try get_byte(reader);
return try get_variant_t(reader, type_id, allocator);
pub fn readQVariant(reader: anytype, allocator: *std.mem.Allocator) !qvar.QVariant {
var type_id = try readUInt(reader);
_ = try readByte(reader);
return try readQVariantT(reader, type_id, allocator);
}
pub fn get_qvariantmap(reader: anytype, allocator: *std.mem.Allocator) !std.StringHashMap(qvar.QVariant) {
pub fn readQVariantMap(reader: anytype, allocator: *std.mem.Allocator) !std.StringHashMap(qvar.QVariant) {
var map = std.StringHashMap(qvar.QVariant).init(allocator);
var numItems = try get_int(reader);
var numItems = try readUInt(reader);
var iter = range(u32, 0, numItems);
while (iter.next()) |i| {
var key = try get_string(reader, allocator);
var value = try get_variant(reader, allocator);
var key = try readString(reader, allocator);
var value = try readQVariant(reader, allocator);
try map.put(key, value);
}

105
src/qtshit/write.zig
View file

@ -1,108 +1,119 @@
const std = @import("std");
const qvar = @import("./qvariant.zig");
pub fn add_int(writer: anytype, number: u32) !void {
const AllKnownErrors = (std.os.WriteError || error{OutOfMemory});
pub fn writeInt(writer: anytype, number: i32) !void {
try writer.writeIntBig(i32, number);
}
pub fn writeUInt(writer: anytype, number: u32) !void {
try writer.writeIntBig(u32, number);
}
pub fn add_short(writer: anytype, number: u16) !void {
pub fn writeShort(writer: anytype, number: u16) !void {
try writer.writeIntBig(u16, number);
}
pub fn add_byte(writer: anytype, byte: u8) !void {
pub fn writeByte(writer: anytype, byte: u8) !void {
try writer.writeByte(byte);
}
pub fn add_bytearray(writer: anytype, array: std.ArrayList(u8)) !void {
try add_int(writer, @intCast(u32, array.items.len));
pub fn writeByteArray(writer: anytype, array: std.ArrayList(u8)) !void {
try writeUInt(writer, @intCast(u32, array.items.len));
try writer.writeAll(array.items);
}
pub fn add_string(writer: anytype, allocator: *std.mem.Allocator, str: []const u8) !void {
pub fn writeString(writer: anytype, allocator: *std.mem.Allocator, str: []const u8) !void {
var ut16Str = try allocator.alloc(u16, str.len);
defer allocator.free(ut16Str);
for (str) |character, index| {
ut16Str[index] = std.mem.nativeToBig(u16, @as(u16, character));
}
// std.debug.print("add_lenchars: {d} {d} \n", .{@intCast(i32, ut16Str.len*8*2), str.len});
try writer.writeIntBig(i32, @intCast(i32, ut16Str.len*2));
try writer.writeAll(std.mem.sliceAsBytes(ut16Str));
try writeInt(writer, @intCast(i32, ut16Str.len * 2));
try writer.writeAll(std.mem.sliceAsBytes(ut16Str));
}
pub fn add_stringlist(writer: anytype, allocator: *std.mem.Allocator, strList: std.ArrayList([]const u8)) !void {
try add_int(writer, @intCast(u32, strList.items.len));
pub fn writeQStringList(writer: anytype, allocator: *std.mem.Allocator, strList: std.ArrayList([]const u8)) !void {
try writeUInt(writer, @intCast(u32, strList.items.len));
for (strList.items) |string| {
try add_string(writer, allocator, string);
try writeString(writer, allocator, string);
}
}
pub fn add_variantlist(writer: anytype, allocator: *std.mem.Allocator, varList: std.ArrayList([]qvar.QVariant)) !void {
try add_int(writer, @intCast(u32, varList.items.len));
pub fn writeQVariantList(writer: anytype, allocator: *std.mem.Allocator, varList: std.ArrayList(qvar.QVariant)) AllKnownErrors!void {
try writeUInt(writer, @intCast(u32, varList.items.len));
for (varList.items) |v| {
try add_variant(writer, allocator, v);
try writeQVariant(writer, allocator, v);
}
}
// Call this and Then write your type
pub fn add_qvariant_with_id(writer: anytype, type_id: u32) !void {
try add_int(writer, type_id);
try add_byte(writer, 0);
pub fn writeQVariantHeader(writer: anytype, type_id: u32) !void {
try writeUInt(writer, type_id);
try writeByte(writer, 0);
}
pub fn add_qvariant(writer: anytype, allocator: *std.mem.Allocator, variant: qvar.QVariant) !void {
try add_qvariant_with_id(writer, try qvar.qvariant_type_id(variant));
pub fn writeQVariant(writer: anytype, allocator: *std.mem.Allocator, variant: qvar.QVariant) !void {
try writeQVariantHeader(writer, try qvar.qvariant_type_id(variant));
switch (variant) {
.byte => |out| {
try add_byte(writer, out);
.Byte => |out| {
try writeByte(writer, out);
},
.int => |out| {
try add_int(writer, out);
.Int => |out| {
try writeInt(writer, out);
},
.qmap => |out| {
try add_qvariantmap(writer, allocator, out);
.UInt => |out| {
try writeUInt(writer, out);
},
.string => |out| {
try add_string(writer, allocator, out);
.QVariantMap => |out| {
try writeQVariantMap(writer, allocator, out);
},
.stringlist => |out| {
try add_stringlist(writer, allocator, out);
.QVariantList => |out| {
try writeQVariantList(writer, allocator, out);
},
.bytearray => |out| {
try add_bytearray(writer, out);
.String => |out| {
try writeString(writer, allocator, out);
},
.short => |out| {
try add_short(writer, out);
.QStringList => |out| {
try writeQStringList(writer, allocator, out);
},
else => {
@panic("Unsupported!");
.QByteArray => |out| {
try writeByteArray(writer, out);
},
.Short => |out| {
try writeShort(writer, out);
},
//else => {
// @panic("Unsupported!");
//},
}
}
pub fn add_qvariantmap(writer: anytype, allocator: *std.mem.Allocator, map: std.StringHashMap(qvar.QVariant)) (@TypeOf(writer).Error || std.os.WriteError || error{OutOfMemory})!void {
pub fn writeQVariantMap(writer: anytype, allocator: *std.mem.Allocator, map: std.StringHashMap(qvar.QVariant)) (@TypeOf(writer).Error || std.os.WriteError || error{OutOfMemory})!void {
var data = std.ArrayList(u8).init(allocator);
defer data.deinit();
var writeIterator = map.iterator();
while (writeIterator.next()) |entry| {
try add_string(data.writer(), allocator, entry.key);
try add_qvariant(data.writer(), allocator, entry.value);
try writeString(data.writer(), allocator, entry.key);
try writeQVariant(data.writer(), allocator, entry.value);
}
// qvariantmap type
try add_int(writer, @enumToInt(qvar.QVariantTypes.qmap));
try add_byte(writer, 0);
try add_int(writer, map.count());
try writeUInt(writer, map.count());
try writer.writeAll(data.items);
return;
}
pub fn add_message(writer: anytype, allocator: *std.mem.Allocator, map: std.StringHashMap(qvar.QVariant)) (@TypeOf(writer).Error || std.os.WriteError || error{OutOfMemory})!void {
pub fn writeFrame(writer: anytype, allocator: *std.mem.Allocator, map: std.StringHashMap(qvar.QVariant)) (@TypeOf(writer).Error || std.os.WriteError || error{OutOfMemory})!void {
var data = std.ArrayList(u8).init(allocator);
try add_qvariantmap(data.writer(), allocator, map);
try writeQVariant(data.writer(), allocator, .{
.QVariantMap = map,
});
try add_int(writer, @intCast(u32, data.items.len));
try writeUInt(writer, @intCast(u32, data.items.len));
try writer.writeAll(data.items);
return;