hohn/codeql
1
0
Fork 0
mirror of https://github.com/github/codeql.git synced 2026-05-02 12:15:17 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #12049 from joefarebrother/netty-models

Browse Source 
Java: Model the Netty framework
This commit is contained in:
Joe Farebrother
2023-03-27 11:38:11 +01:00
committed by GitHub
parent 6d91458586 48823aec75
commit 489ce3d40a
141 changed files with 12428 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
java/ql/lib/change-notes/2023-02-28-netty.md Normal file
View File

@@ -0,0 +1,4 @@
---
category: minorAnalysis
---
* Added sources and flow step models for the Netty framework up to version 4.1.

212
java/ql/lib/ext/io.netty.buffer.model.yml Normal file
View File

@@ -0,0 +1,212 @@
extensions:
- addsTo:
pack: codeql/java-all
extensible: summaryModel
data:
- ["io.netty.buffer", "ByteBufConvertible", True, "asByteBuf", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "array", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "asReadOnly", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "capacity", "(int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "copy", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "discardReadBytes", "()", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "discardSomeReadBytes", "()", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "duplicate", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "ensureWritable", "(int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,byte[])", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,byte[],int,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,ByteBuf)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,ByteBuffer)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,ByteBuf,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,ByteBuf,int,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,OutputStream,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "markReaderIndex", "()", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "markWriterIndex", "()", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "nioBuffer", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "nioBuffers", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "order", "(ByteOrder)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(byte[])", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(byte[],int,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(ByteBuf)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(ByteBuffer)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(ByteBuf,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(ByteBuf,int,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(OutputStream,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readerIndex", "(int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "resetReaderIndex", "()", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "resetWriterIndex", "()", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "retainedDuplicate", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "retainedSlice", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBoolean", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setByte", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,byte[])", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,byte[],int,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,ByteBuf)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,ByteBuffer)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,ByteBuf,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,ByteBuf,int,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setChar", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setDouble", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setDoubleLE", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setFloat", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setFloatLE", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setIndex", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setInt", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setIntLE", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setLong", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setLongLE", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setMedium", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setMediumLE", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setShort", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setShortLE", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setZero", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "skipBytes", "(int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "slice", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "toString", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "unwrap", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBoolean", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeByte", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(byte[])", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(byte[],int,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(ByteBuf)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(ByteBuffer)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(ByteBuf,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(ByteBuf,int,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeChar", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeDouble", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeDoubleLE", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeFloat", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeFloatLE", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeInt", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeIntLE", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeLong", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeLongLE", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeMedium", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeMediumLE", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeShort", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeShortLE", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeZero", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writerIndex", "(int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBufHolder", True, "copy", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufHolder", True, "content", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufHolder", True, "duplicate", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufHolder", True, "retainedDuplicate", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufHolder", True, "replace", "(ByteBuf)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,byte[])", "", "Argument[this]", "Argument[1]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,byte[],int,int)", "", "Argument[this]", "Argument[1]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,ByteBuf)", "", "Argument[this]", "Argument[1]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,ByteBuffer)", "", "Argument[this]", "Argument[1]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,ByteBuf,int)", "", "Argument[this]", "Argument[1]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,ByteBuf,int,int)", "", "Argument[this]", "Argument[1]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,FileChannel,long,int)", "", "Argument[this]", "Argument[1]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,GatheringByteChannel,int)", "", "Argument[this]", "Argument[1]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getBytes", "(int,OutputStream,int)", "", "Argument[this]", "Argument[1]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getChar", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "getCharSequence", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(byte[])", "", "Argument[this]", "Argument[0]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(byte[],int,int)", "", "Argument[this]", "Argument[0]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(ByteBuf)", "", "Argument[this]", "Argument[0]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(ByteBuffer)", "", "Argument[this]", "Argument[0]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(ByteBuf,int)", "", "Argument[this]", "Argument[0]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(ByteBuf,int,int)", "", "Argument[this]", "Argument[0]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(FileChannel,long,int)", "", "Argument[this]", "Argument[0]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(GatheringByteChannel,int)", "", "Argument[this]", "Argument[0]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(OutputStream,int)", "", "Argument[this]", "Argument[0]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readBytes", "(int)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readChar", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readCharSequence", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readSlice", "(int)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "readRetainedSlice", "(int)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,byte[])", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,byte[],int,int)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,ByteBuf)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,ByteBuffer)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,ByteBuf,int)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,ByteBuf,int,int)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,FileChannel,long,int)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,ScatteringByteChannel,int)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setBytes", "(int,InputStream,int)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setChar", "", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "setCharSequence", "", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeByte", "", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(byte[])", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(byte[],int,int)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(ByteBuf)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(ByteBuffer)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(ByteBuf,int)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(ByteBuf,int,int)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(FileChannel,long,int)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(ScatteringByteChannel,int)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeBytes", "(InputStream,int)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeChar", "", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBuf", True, "writeCharSequence", "", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", False, "CompositeByteBuf", "(ByteBufAllocator,boolean,int,ByteBuf[])", "", "Argument[3].ArrayElement", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", False, "CompositeByteBuf", "(ByteBufAllocator,boolean,int,Iterable)", "", "Argument[3].Element", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "addComponent", "(ByteBuf)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "addComponent", "(int,ByteBuf)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "addComponent", "(boolean,ByteBuf)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "addComponent", "(boolean,int,ByteBuf)", "", "Argument[2]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "addComponents", "(ByteBuf[])", "", "Argument[0].ArrayElement", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "addComponents", "(int,ByteBuf[])", "", "Argument[1].ArrayElement", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "addComponents", "(boolean,ByteBuf[])", "", "Argument[1].ArrayElement", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "addComponents", "(Iterable)", "", "Argument[0].Element", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "addComponents", "(int,Iterable)", "", "Argument[1].Element", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "addComponents", "(boolean,Iterable)", "", "Argument[1].Element", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "addFlattenedComponents", "(boolean,ByteBuf)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "addComponent", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "addComponents", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "addFlattenedComponents", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "component", "(int)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "componentAtOffset", "(int)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "consolidate", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "consolidate", "(int,int)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "CompositeByteBuf", True, "decompose", "(int,int)", "", "Argument[this]", "ReturnValue.Element", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "copiedBuffer", "(byte[])", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "copiedBuffer", "(byte[][])", "", "Argument[0].ArrayElement", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "copiedBuffer", "(byte[],int,int)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "copiedBuffer", "(ByteBuf)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "copiedBuffer", "(ByteBuf[])", "", "Argument[0].ArrayElement", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "copiedBuffer", "(ByteBuffer)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "copiedBuffer", "(ByteBuffer[])", "", "Argument[0].ArrayElement", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "copiedBuffer", "(char[],Charset)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "copiedBuffer", "(char[],int,int,Charset)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "copiedBuffer", "(CharSequence,Charset)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "copiedBuffer", "(CharSequence,int,int,Charset)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "unmodifiableBuffer", "(ByteBuf)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "unmodifiableBuffer", "(ByteBuf[])", "", "Argument[0].ArrayElement", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "unreleasableBuffer", "(ByteBuf)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "wrappedBuffer", "(byte[])", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "wrappedBuffer", "(byte[][])", "", "Argument[0].ArrayElement", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "wrappedBuffer", "(byte[],int,int)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "wrappedBuffer", "(ByteBuf)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "wrappedBuffer", "(ByteBuf[])", "", "Argument[0].ArrayElement", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "wrappedBuffer", "(ByteBuffer)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "wrappedBuffer", "(ByteBuffer[])", "", "Argument[0].ArrayElement", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "wrappedBuffer", "(int,byte[][])", "", "Argument[1].ArrayElement", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "wrappedBuffer", "(int,ByteBuf[])", "", "Argument[1].ArrayElement", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "wrappedBuffer", "(int,ByteBuffer[])", "", "Argument[1].ArrayElement", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "Unpooled", False, "wrappedUnmodifiableBuffer", "(ByteBuf[])", "", "Argument[0].ArrayElement", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "copy", "(AsciiString,ByteBuf)", "", "Argument[0]", "Argument[1]", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "copy", "(AsciiString,int,ByteBuf,int)", "", "Argument[0]", "Argument[2]", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "copy", "(AsciiString,int,ByteBuf,int,int)", "", "Argument[0]", "Argument[2]", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "decodeHexDump", "(CharSequence)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "decodeHexDump", "(CharSequence,int,int)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "encodeString", "(ByteBufAllocator,CharBuffer,Charset)", "", "Argument[1]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "encodeString", "(ByteBufAllocator,CharBuffer,Charset,int)", "", "Argument[1]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "ensureAccessible", "(ByteBuf)", "", "Argument[0]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "getBytes", "(ByteBuf)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "getBytes", "(ByteBuf,int,int)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "getBytes", "(ByteBuf,int,int,boolean)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "readBytes", "(ByteBufAllocator,ByteBuf,int)", "", "Argument[1]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "reserveAndWriteUtf8", "(ByteBuf,CharSequence,int)", "", "Argument[1]", "Argument[0]", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "reserveAndWriteUtf8", "(ByteBuf,CharSequence,int,int,int)", "", "Argument[1]", "Argument[0]", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "setShortBE", "(ByteBuf,int,int)", "", "Argument[0]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "writeAscii", "(ByteBuf,CharSequence)", "", "Argument[1]", "Argument[0]", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "writeAscii", "(ByteBufAllocator,CharSequence)", "", "Argument[1]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "writeShortBE", "(ByteBuf,int)", "", "Argument[0]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "writeMediumBE", "(ByteBuf,int)", "", "Argument[0]", "ReturnValue", "value", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "writeUtf8", "(ByteBuf,CharSequence)", "", "Argument[1]", "Argument[0]", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "writeUtf8", "(ByteBuf,CharSequence,int,int)", "", "Argument[1]", "Argument[0]", "taint", "manual"]
- ["io.netty.buffer", "ByteBufUtil", False, "writeUtf8", "(ByteBufAllocator,CharSequence)", "", "Argument[1]", "ReturnValue", "taint", "manual"]
- ["io.netty.buffer", "ByteBufInputStream", True, "ByteBufInputStream", "", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBufOutputStream", True, "ByteBufOutputStream", "", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.buffer", "ByteBufOutputStream", True, "buffer", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]

6
java/ql/lib/ext/io.netty.channel.model.yml
View File

@@ -12,3 +12,9 @@ extensions:
- ["io.netty.channel", "DefaultChannelPipeline", False, "connect", "(SocketAddress,ChannelPromise)", "", "Argument[0]", "open-url", "ai-generated"]
- ["io.netty.channel", "DefaultChannelPipeline", False, "connect", "(SocketAddress,SocketAddress,ChannelPromise)", "", "Argument[0]", "open-url", "ai-generated"]
- ["io.netty.channel", "DefaultChannelPipeline", False, "connect", "(SocketAddress,SocketAddress)", "", "Argument[0]", "open-url", "ai-generated"]
- addsTo:
pack: codeql/java-all
extensible: sourceModel
data:
- ["io.netty.channel", "ChannelInboundHandler", True, "channelRead", "", "", "Parameter[1]", "remote", "manual"]
- ["io.netty.channel", "SimpleChannelInboundHandler", True, "channelRead0", "", "", "Parameter[1]", "remote", "manual"]

8
java/ql/lib/ext/io.netty.handler.codec.base64.model.yml Normal file
View File

@@ -0,0 +1,8 @@
extensions:
- addsTo:
pack: codeql/java-all
extensible: summaryModel
data:
- ["io.netty.handler.codec.base64", "Base64", True, "decode", "", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.base64", "Base64", True, "encode", "", "", "Argument[0]", "ReturnValue", "taint", "manual"]

19
java/ql/lib/ext/io.netty.handler.codec.http.cookie.model.yml Normal file
View File

@@ -0,0 +1,19 @@
extensions:
- addsTo:
pack: codeql/java-all
extensible: summaryModel
data:
- ["io.netty.handler.codec.http.cookie", "Cookie", True, "domain", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.cookie", "Cookie", True, "name", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.cookie", "Cookie", True, "path", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.cookie", "Cookie", True, "value", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.cookie", "Cookie", True, "setDomain", "(String)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.cookie", "Cookie", True, "setPath", "(String)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.cookie", "Cookie", True, "setValue", "(String)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.cookie", "ServerCookieDecoder", True, "decode", "(String)", "", "Argument[0]", "ReturnValue.Element", "taint", "manual"]
- ["io.netty.handler.codec.http.cookie", "ServerCookieDecoder", True, "decodeAll", "(String)", "", "Argument[0]", "ReturnValue.Element", "taint", "manual"]
- ["io.netty.handler.codec.http.cookie", "ServerCookieEncoder", True, "encode", "(Cookie)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.cookie", "ServerCookieEncoder", True, "encode", "(Cookie[])", "", "Argument[0].ArrayElement", "ReturnValue.Element", "taint", "manual"]
- ["io.netty.handler.codec.http.cookie", "ServerCookieEncoder", True, "encode", "(Collection)", "", "Argument[0].Element", "ReturnValue.Element", "taint", "manual"]
- ["io.netty.handler.codec.http.cookie", "ServerCookieEncoder", True, "encode", "(Iterable)", "", "Argument[0].Element", "ReturnValue.Element", "taint", "manual"]
- ["io.netty.handler.codec.http.cookie", "ServerCookieEncoder", True, "encode", "(String,String)", "", "Argument[1..2]", "ReturnValue", "taint", "manual"]

93
java/ql/lib/ext/io.netty.handler.codec.http.model.yml
View File

@@ -1,12 +1,83 @@
extensions:
- addsTo:
pack: codeql/java-all
extensible: sinkModel
data:
- ["io.netty.handler.codec.http", "DefaultFullHttpRequest", True, "DefaultFullHttpRequest", "(HttpVersion,HttpMethod,String,ByteBuf)", "", "Argument[2]", "open-url", "ai-generated"]
- ["io.netty.handler.codec.http", "DefaultHttpRequest", True, "DefaultHttpRequest", "(HttpVersion,HttpMethod,String)", "", "Argument[2]", "open-url", "ai-generated"]
- addsTo:
pack: codeql/java-all
extensible: summaryModel
data:
- ["io.netty.handler.codec.http", "QueryStringEncoder", True, "QueryStringEncoder", "(String)", "", "Argument[0]", "Argument[this]", "taint", "ai-generated"]
- addsTo:
pack: codeql/java-all
extensible: sinkModel
data:
- ["io.netty.handler.codec.http", "DefaultFullHttpRequest", True, "DefaultFullHttpRequest", "(HttpVersion,HttpMethod,String,ByteBuf)", "", "Argument[2]", "open-url", "ai-generated"]
- ["io.netty.handler.codec.http", "DefaultHttpRequest", True, "DefaultHttpRequest", "(HttpVersion,HttpMethod,String)", "", "Argument[2]", "open-url", "ai-generated"]
- addsTo:
pack: codeql/java-all
extensible: summaryModel
data:
- ["io.netty.handler.codec.http", "QueryStringEncoder", True, "QueryStringEncoder", "(String)", "", "Argument[0]", "Argument[this]", "taint", "ai-generated"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "add", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "add", "(CharSequence,Iterable)", "", "Argument[0]", "Argument[this].Element.MapKey", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "add", "(CharSequence,Iterable)", "", "Argument[1].Element", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "add", "(CharSequence,Object)", "", "Argument[0]", "Argument[this].Element.MapKey", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "add", "(CharSequence,Object)", "", "Argument[1]", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "add", "(String,Iterable)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "add", "(String,Iterable)", "", "Argument[1].Element", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "add", "(String,Object)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "add", "(String,Object)", "", "Argument[1]", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "add", "(HttpHeaders)", "", "Argument[0].Element.MapKey", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "add", "(HttpHeaders)", "", "Argument[0].Element.MapValue", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "addInt", "(CharSequence,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "addInt", "(CharSequence,int)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "addShort", "(CharSequence,short)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "addShort", "(CharSequence,short)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "copy", "()", "", "Argument[this].Element.MapKey", "ReturnValue.Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "copy", "()", "", "Argument[this].Element.MapValue", "ReturnValue.Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "entries", "()", "", "Argument[this].Element.MapKey", "ReturnValue.Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "entries", "()", "", "Argument[this].Element.MapValue", "ReturnValue.Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "get", "", "", "Argument[this].Element.MapValue", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "get", "", "", "Argument[1]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "getAll", "", "", "Argument[this].Element.MapValue", "ReturnValue.Element", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "getAllAsString", "", "", "Argument[this].Element.MapValue", "ReturnValue.Element", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "getAsString", "", "", "Argument[this].Element.MapValue", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "getHeader", "", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "getHeader", "", "", "Argument[2]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "getHost", "", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "getHost", "", "", "Argument[1]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "iteratorAsString", "()", "", "Argument[this].Element.MapKey", "ReturnValue.Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "iteratorAsString", "()", "", "Argument[this].Element.MapValue", "ReturnValue.Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "iteratorCharSequence", "()", "", "Argument[this].Element.MapKey", "ReturnValue.Element.MapKey", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "iteratorCharSequence", "()", "", "Argument[this].Element.MapValue", "ReturnValue.Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "names", "()", "", "Argument[this].Element.MapKey", "ReturnValue.Element", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "newEntity", "", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "remove", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "set", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "set", "(CharSequence,Iterable)", "", "Argument[0]", "Argument[this].Element.MapKey", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "set", "(CharSequence,Iterable)", "", "Argument[1].Element", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "set", "(CharSequence,Object)", "", "Argument[0]", "Argument[this].Element.MapKey", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "set", "(CharSequence,Object)", "", "Argument[1]", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "set", "(String,Iterable)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "set", "(String,Iterable)", "", "Argument[1].Element", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "set", "(String,Object)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "set", "(String,Object)", "", "Argument[1]", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "set", "(HttpHeaders)", "", "Argument[0].Element.MapKey", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "set", "(HttpHeaders)", "", "Argument[0].Element.MapValue", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "setAll", "(HttpHeaders)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "setAll", "(HttpHeaders)", "", "Argument[0].Element.MapKey", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "setAll", "(HttpHeaders)", "", "Argument[0].Element.MapValue", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "setInt", "(CharSequence,int)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "setInt", "(CharSequence,int)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "setShort", "(CharSequence,short)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "setShort", "(CharSequence,short)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "valueStringIterator", "(CharSequence)", "", "Argument[this].Element.MapValue", "ReturnValue.Element", "value", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "valueCharSequenceIterator", "(CharSequence)", "", "Argument[this].Element.MapValue", "ReturnValue.Element", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "toString", "", "", "Argument[this].Element.MapKey", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpHeaders", True, "toString", "", "", "Argument[this].Element.MapValue", "ReturnValue", "taint", "manual"]
# Currently all write steps to http messages are taint flow. It may reduce FPs to use a synthetic field for headers instead.
- ["io.netty.handler.codec.http", "HttpMessage", True, "headers", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "LastHttpContent", True, "trailingHeaders", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpRequest", True, "getUri", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpRequest", True, "uri", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "HttpRequest", True, "setUri", "", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http", "QueryStringDecoder", True, "QueryStringDecoder", "", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http", "QueryStringDecoder", True, "decodeComponent", "", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "QueryStringDecoder", True, "parameters", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "QueryStringDecoder", True, "path", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "QueryStringDecoder", True, "rawPath", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "QueryStringDecoder", True, "rawQuery", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "QueryStringDecoder", True, "toString", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http", "QueryStringDecoder", True, "uri", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]

37
java/ql/lib/ext/io.netty.handler.codec.http.multipart.model.yml
View File

@@ -4,3 +4,40 @@ extensions:
extensible: sinkModel
data:
- ["io.netty.handler.codec.http.multipart", "HttpPostRequestEncoder", True, "addBodyFileUpload", "(String,File,String,boolean)", "", "Argument[1]", "read-file", "ai-generated"]
- addsTo:
pack: codeql/java-all
extensible: summaryModel
data:
- ["io.netty.handler.codec.http.multipart", "InterfaceHttpPostRequestDecoder", True, "currentPartialHttpData", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "InterfaceHttpPostRequestDecoder", True, "getBodyHttpData", "(String)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "InterfaceHttpPostRequestDecoder", True, "getBodyHttpDatas", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "InterfaceHttpPostRequestDecoder", True, "getBodyHttpDatas", "(String)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "InterfaceHttpPostRequestDecoder", True, "next", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "InterfaceHttpPostRequestDecoder", True, "offer", "(HttpContent)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "InterfaceHttpPostRequestDecoder", True, "offer", "(HttpContent)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpPostRequestDecoder", True, "HttpPostRequestDecoder", "(HttpRequest)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpPostRequestDecoder", True, "HttpPostRequestDecoder", "(HttpDataFactory,HttpRequest)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpPostRequestDecoder", True, "HttpPostRequestDecoder", "(HttpDataFactory,HttpRequest,Charset)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpPostStandardRequestDecoder", True, "HttpPostStandardRequestDecoder", "(HttpRequest)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpPostStandardRequestDecoder", True, "HttpPostStandardRequestDecoder", "(HttpDataFactory,HttpRequest)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpPostStandardRequestDecoder", True, "HttpPostStandardRequestDecoder", "(HttpDataFactory,HttpRequest,Charset)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpPostMultipartRequestDecoder", True, "HttpPostMultipartRequestDecoder", "(HttpRequest)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpPostMultipartRequestDecoder", True, "HttpPostMultipartRequestDecoder", "(HttpDataFactory,HttpRequest)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpPostMultipartRequestDecoder", True, "HttpPostMultipartRequestDecoder", "(HttpDataFactory,HttpRequest,Charset)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "InterfaceHttpData", True, "getName", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpData", True, "addContent", "(ByteBuf,boolean)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpData", True, "get", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpData", True, "getByteBuf", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpData", True, "getChunk", "(int)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpData", True, "getString", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpData", True, "getString", "(Charset)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "Attribute", True, "getValue", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "Attribute", True, "setValue", "(String)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "FileUpload", True, "getContentTransferEncoding", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "FileUpload", True, "getContentType", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "FileUpload", True, "getFilename", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "FileUpload", True, "setContentTransferEncoding", "(String)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "FileUpload", True, "setContentType", "(String)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "FileUpload", True, "setFilename", "(String)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpData", True, "setContent", "(ByteBuf)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.multipart", "HttpData", True, "setContent", "(InputStream)", "", "Argument[0]", "Argument[this]", "taint", "manual"]

25
java/ql/lib/ext/io.netty.handler.codec.http.websocketx.model.yml Normal file
View File

@@ -0,0 +1,25 @@
extensions:
- addsTo:
pack: codeql/java-all
extensible: summaryModel
data:
- ["io.netty.handler.codec.http.websocketx", "CloseWebSocketFrame", True, "CloseWebSocketFrame", "(boolean,int,ByteBuf)", "", "Argument[2]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "CloseWebSocketFrame", True, "CloseWebSocketFrame", "(boolean,int,int,String)", "", "Argument[3]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "CloseWebSocketFrame", True, "CloseWebSocketFrame", "(int,String)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "CloseWebSocketFrame", True, "CloseWebSocketFrame", "(WebSocketCloseStatus,String)", "", "Argument[1]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "CloseWebSocketFrame", True, "reasonText", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "BinaryWebSocketFrame", True, "BinaryWebSocketFrame", "(boolean,int,ByteBuf)", "", "Argument[2]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "BinaryWebSocketFrame", True, "BinaryWebSocketFrame", "(ByteBuf)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "ContinuationWebSocketFrame", True, "ContinuationWebSocketFrame", "(boolean,int,ByteBuf)", "", "Argument[2]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "ContinuationWebSocketFrame", True, "ContinuationWebSocketFrame", "(boolean,int,String)", "", "Argument[2]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "ContinuationWebSocketFrame", True, "ContinuationWebSocketFrame", "(ByteBuf)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "ContinuationWebSocketFrame", True, "text", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "PingWebSocketFrame", True, "PingWebSocketFrame", "(boolean,int,ByteBuf)", "", "Argument[2]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "PingWebSocketFrame", True, "PingWebSocketFrame", "(ByteBuf)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "PongWebSocketFrame", True, "PongWebSocketFrame", "(boolean,int,ByteBuf)", "", "Argument[2]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "PongWebSocketFrame", True, "PongWebSocketFrame", "(ByteBuf)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "TextWebSocketFrame", True, "TextWebSocketFrame", "(boolean,int,ByteBuf)", "", "Argument[2]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "TextWebSocketFrame", True, "TextWebSocketFrame", "(boolean,int,String)", "", "Argument[2]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "TextWebSocketFrame", True, "TextWebSocketFrame", "(String)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "TextWebSocketFrame", True, "TextWebSocketFrame", "(ByteBuf)", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.handler.codec.http.websocketx", "TextWebSocketFrame", True, "text", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]

49
java/ql/lib/ext/io.netty.handler.codec.http2.model.yml Normal file
View File

@@ -0,0 +1,49 @@
extensions:
- addsTo:
pack: codeql/java-all
extensible: sourceModel
data:
- ["io.netty.handler.codec.http2", "Http2FrameListener", True, "onDataRead", "", "", "Parameter[2]", "remote", "manual"]
- ["io.netty.handler.codec.http2", "Http2FrameListener", True, "onHeadersRead", "", "", "Parameter[2]", "remote", "manual"]
- ["io.netty.handler.codec.http2", "Http2FrameListener", True, "onPushPromiseRead", "", "", "Parameter[3]", "remote", "manual"]
- ["io.netty.handler.codec.http2", "Http2FrameListener", True, "onUnknownFrame", "", "", "Parameter[4]", "remote", "manual"]
- addsTo:
pack: codeql/java-all
extensible: summaryModel
data:
- ["io.netty.handler.codec.http2", "Http2Headers", True, "authority", "()", "", "Argument[this].Element.MapValue", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "authority", "(CharSequence)", "", "Argument[0]", "Argument[this].Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "authority", "(CharSequence)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "method", "()", "", "Argument[this].Element.MapValue", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "method", "(CharSequence)", "", "Argument[0]", "Argument[this].Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "method", "(CharSequence)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "path", "()", "", "Argument[this].Element.MapValue", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "path", "(CharSequence)", "", "Argument[0]", "Argument[this].Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "path", "(CharSequence)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "scheme", "()", "", "Argument[this].Element.MapValue", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "scheme", "(CharSequence)", "", "Argument[0]", "Argument[this].Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "scheme", "(CharSequence)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "status", "()", "", "Argument[this].Element.MapValue", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "status", "(CharSequence)", "", "Argument[0]", "Argument[this].Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "status", "(CharSequence)", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2Headers", True, "valueIterator", "(CharSequence)", "", "Argument[this].Element.MapValue", "ReturnValue.Element", "value", "manual"]
- ["io.netty.handler.codec.http2", "Http2HeadersFrame", True, "headers", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http2", "Http2PushPromiseFrame", True, "http2Headers", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "addHttp2ToHttpHeaders", "(int,Http2Headers,FullHttpMessage,boolean)", "", "Argument[1].Element.MapKey", "Argument[2]", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "addHttp2ToHttpHeaders", "(int,Http2Headers,FullHttpMessage,boolean)", "", "Argument[1].Element.MapValue", "Argument[2]", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "addHttp2ToHttpHeaders", "(int,Http2Headers,HttpHeaders,HttpVersion,boolean,boolean)", "", "Argument[1].Element.MapKey", "Argument[2].Element.MapKey", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "addHttp2ToHttpHeaders", "(int,Http2Headers,HttpHeaders,HttpVersion,boolean,boolean)", "", "Argument[1].Element.MapValue", "Argument[2].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "toFullHttpRequest", "", "", "Argument[1].Element.MapKey", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "toFullHttpRequest", "", "", "Argument[1].Element.MapValue", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "toFullHttpRequest", "(int,Http2Headers,ByteBuf,boolean)", "", "Argument[2]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "toFullHttpResponse", "", "", "Argument[1].Element.MapKey", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "toFullHttpResponse", "", "", "Argument[1].Element.MapValue", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "toFullHttpResponse", "(int,Http2Headers,ByteBuf,boolean)", "", "Argument[2]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "toHttp2Headers", "(HttpHeaders,boolean)", "", "Argument[0].Element.MapKey", "ReturnValue.Element.MapKey", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "toHttp2Headers", "(HttpHeaders,boolean)", "", "Argument[0].Element.MapValue", "ReturnValue.Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "toHttp2Headers", "(HttpHeaders,Http2Headers)", "", "Argument[0].Element.MapKey", "Argument[1].Element.MapKey", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "toHttp2Headers", "(HttpHeaders,Http2Headers)", "", "Argument[0].Element.MapValue", "Argument[1].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "toHttpRequest", "", "", "Argument[1].Element.MapKey", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "toHttpRequest", "", "", "Argument[1].Element.MapValue", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "toHttpResponse", "", "", "Argument[1].Element.MapKey", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec.http2", "HttpConversionUtil", False, "toHttpResponse", "", "", "Argument[1].Element.MapValue", "ReturnValue", "taint", "manual"]

103
java/ql/lib/ext/io.netty.handler.codec.model.yml Normal file
View File

@@ -0,0 +1,103 @@
extensions:
- addsTo:
pack: codeql/java-all
extensible: sourceModel
data:
- ["io.netty.handler.codec", "ByteToMessageDecoder", True, "callDecode", "", "", "Parameter[1]", "remote", "manual"]
- ["io.netty.handler.codec", "ByteToMessageDecoder", True, "decode", "", "", "Parameter[1]", "remote", "manual"]
- ["io.netty.handler.codec", "ByteToMessageDecoder", True, "decodeLast", "", "", "Parameter[1]", "remote", "manual"]
- ["io.netty.handler.codec", "ByteToMessageCodec", True, "decode", "", "", "Parameter[1]", "remote", "manual"]
- ["io.netty.handler.codec", "ByteToMessageCodec", True, "decodeLast", "", "", "Parameter[1]", "remote", "manual"]
- ["io.netty.handler.codec", "MessageToMessageDecoder", True, "acceptInboundMessage", "", "", "Parameter[0]", "remote", "manual"]
- ["io.netty.handler.codec", "MessageToMessageDecoder", True, "decode", "", "", "Parameter[1]", "remote", "manual"]
- ["io.netty.handler.codec", "MessageToMessageCodec", True, "acceptInboundMessage", "", "", "Parameter[0]", "remote", "manual"]
- ["io.netty.handler.codec", "MessageToMessageCodec", True, "decode", "", "", "Parameter[1]", "remote", "manual"]
- addsTo:
pack: codeql/java-all
extensible: summaryModel
data:
- ["io.netty.handler.codec", "ByteToMessageDecoder$Cumulator", True, "cumulate", "(ByteBufAllocator,ByteBuf,ByteBuf)", "", "Argument[1..2]", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec", "HeadersUtils", False, "getAsString", "(Headers,Object)", "", "Argument[0].Element.MapValue", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec", "HeadersUtils", False, "getAllAsString", "(Headers,Object)", "", "Argument[0].Element.MapValue", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec", "HeadersUtils", False, "namesAsString", "(Headers)", "", "Argument[0].Element.MapKey", "ReturnValue.Element", "value", "manual"]
- ["io.netty.handler.codec", "HeadersUtils", False, "iteratorAsString", "(Iterable)", "", "Argument[0].Element.MapKey", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec", "HeadersUtils", False, "iteratorAsString", "(Iterable)", "", "Argument[0].Element.MapValue", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec", "HeadersUtils", False, "toString", "(Class,Iterator,int)", "", "Argument[1].Element.MapKey", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec", "HeadersUtils", False, "toString", "(Class,Iterator,int)", "", "Argument[1].Element.MapValue", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec", "Headers", True, "get", "(Object)", "", "Argument[this].Element.MapValue", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec", "Headers", True, "get", "(Object,Object)", "", "Argument[this].Element.MapValue", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec", "Headers", True, "get", "(Object,Object)", "", "Argument[1]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "getAll", "(Object)", "", "Argument[this].Element.MapValue", "ReturnValue.Element", "taint", "manual"]
- ["io.netty.handler.codec", "Headers", True, "getAllAndRemove", "(Object)", "", "Argument[this].Element.MapValue", "ReturnValue.Element", "taint", "manual"]
- ["io.netty.handler.codec", "Headers", True, "getAndRemove", "(Object)", "", "Argument[this].Element.MapValue", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec", "Headers", True, "getAndRemove", "(Object)", "", "Argument[this].Element.MapValue", "ReturnValue", "taint", "manual"]
- ["io.netty.handler.codec", "Headers", True, "getAndRemove", "(Object,Object)", "", "Argument[1]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "names", "()", "", "Argument[this].Element.MapKey", "ReturnValue.Element", "taint", "manual"]
- ["io.netty.handler.codec", "Headers", True, "add", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "add", "(Headers)", "", "Argument[0].Element.MapKey", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "add", "(Headers)", "", "Argument[0].Element.MapValue", "Argument[this].Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "add", "(Object,Iterable)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "add", "(Object,Iterable)", "", "Argument[1].Element", "Argument[this].Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "add", "(Object,Object[])", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "add", "(Object,Object[])", "", "Argument[1].ArrayElement", "Argument[this].Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "add", "(Object,Object)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "add", "(Object,Object)", "", "Argument[1]", "Argument[this].Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addObject", "(Object,Iterable)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addObject", "(Object,Iterable)", "", "Argument[1].Element", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addObject", "(Object,Object[])", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addObject", "(Object,Object[])", "", "Argument[1].ArrayElement", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addObject", "(Object,Object)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addObject", "(Object,Object)", "", "Argument[1]", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addBoolean", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addBoolean", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addByte", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addByte", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addChar", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addChar", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addDouble", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addDouble", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addFloat", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addFloat", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addInt", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addInt", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addLong", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addLong", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addShort", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addShort", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addTimeMillis", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "addTimeMillis", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "set", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "set", "(Headers)", "", "Argument[0].Element.MapKey", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "set", "(Headers)", "", "Argument[0].Element.MapValue", "Argument[this].Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "set", "(Object,Iterable)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "set", "(Object,Iterable)", "", "Argument[1].Element", "Argument[this].Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "set", "(Object,Object[])", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "set", "(Object,Object[])", "", "Argument[1].ArrayElement", "Argument[this].Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "set", "(Object,Object)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "set", "(Object,Object)", "", "Argument[1]", "Argument[this].Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setAll", "(Headers)", "", "Argument[0].Element.MapKey", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setAll", "(Headers)", "", "Argument[0].Element.MapValue", "Argument[this].Element.MapValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setObject", "(Object,Iterable)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setObject", "(Object,Iterable)", "", "Argument[1].Element", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setObject", "(Object,Object[])", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setObject", "(Object,Object[])", "", "Argument[1].ArrayElement", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setObject", "(Object,Object)", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setObject", "(Object,Object)", "", "Argument[1]", "Argument[this].Element.MapValue", "taint", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setBoolean", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setBoolean", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setByte", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setByte", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setChar", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setChar", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setDouble", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setDouble", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setFloat", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setFloat", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setInt", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setInt", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setLong", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setLong", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setShort", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setShort", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setTimeMillis", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.handler.codec", "Headers", True, "setTimeMillis", "", "", "Argument[0]", "Argument[this].Element.MapKey", "value", "manual"]

27
java/ql/lib/ext/io.netty.util.model.yml Normal file
View File

@@ -0,0 +1,27 @@
extensions:
- addsTo:
pack: codeql/java-all
extensible: summaryModel
data:
- ["io.netty.util", "ReferenceCounted", True, "retain", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.util", "ReferenceCounted", True, "touch", "", "", "Argument[this]", "ReturnValue", "value", "manual"]
- ["io.netty.util", "AsciiString", False, "AsciiString", "", "", "Argument[0]", "Argument[this]", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "array", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "cached", "(String)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "concat", "(CharSequence)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "concat", "(CharSequence)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "copy", "(int,byte[],int,int)", "", "Argument[this]", "Argument[1]", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "copy", "(int,char[],int,int)", "", "Argument[this]", "Argument[1]", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "of", "(CharSequence)", "", "Argument[0]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "replace", "(char,char)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "split", "(char)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "split", "(String,int)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "split", "(char)", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "subSequence", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "toByteArray", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "toCharArray", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "toString", "", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "toLowerCase", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "toUpperCase", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "trim", "()", "", "Argument[this]", "ReturnValue", "taint", "manual"]
- ["io.netty.util", "AsciiString", False, "trim", "(CharSequence)", "", "Argument[0]", "ReturnValue", "taint", "manual"]

7895
java/ql/test/library-tests/frameworks/netty/generated/Test.java Normal file
View File

File diff suppressed because it is too large Load Diff

2
java/ql/test/library-tests/frameworks/netty/Test.java → java/ql/test/library-tests/frameworks/netty/generated/TestA.java
View File

@@ -4,7 +4,7 @@ import io.netty.resolver.SimpleNameResolver;
import io.netty.util.concurrent.Future;
// Test case generated by GenerateFlowTestCase.ql
public class Test {
public class TestA {
Object source() {
return null;

2
java/ql/test/library-tests/frameworks/netty/options → java/ql/test/library-tests/frameworks/netty/generated/options
View File

@@ -1 +1 @@
//semmle-extractor-options: --javac-args -cp ${testdir}/../../../stubs/netty-4.1.x
//semmle-extractor-options: --javac-args -cp ${testdir}/../../../../stubs/netty-4.1.x

0
java/ql/test/library-tests/frameworks/netty/test.expected → java/ql/test/library-tests/frameworks/netty/generated/test.expected
View File

11
java/ql/test/library-tests/frameworks/netty/generated/test.ext.yml Normal file
View File

@@ -0,0 +1,11 @@
extensions:
- addsTo:
pack: codeql/java-tests
extensible: summaryModel
data:
- ["generatedtest", "Test", False, "newWithMapValueDefault", "(Object)", "", "Argument[0]", "ReturnValue.MapValue", "value", "manual"]
- ["generatedtest", "Test", False, "newWithMapKeyDefault", "(Object)", "", "Argument[0]", "ReturnValue.MapKey", "value", "manual"]
- ["generatedtest", "Test", False, "newWithElementDefault", "(Object)", "", "Argument[0]", "ReturnValue.Element", "value", "manual"]
- ["generatedtest", "Test", False, "getMapValueDefault", "(Object)", "", "Argument[0].MapValue", "ReturnValue", "value", "manual"]
- ["generatedtest", "Test", False, "getMapKeyDefault", "(Object)", "", "Argument[0].MapKey", "ReturnValue", "value", "manual"]
- ["generatedtest", "Test", False, "getElementDefault", "(Object)", "", "Argument[0].Element", "ReturnValue", "value", "manual"]

0
java/ql/test/library-tests/frameworks/netty/test.ql → java/ql/test/library-tests/frameworks/netty/generated/test.ql
View File

76
java/ql/test/library-tests/frameworks/netty/manual/Test.java Normal file
View File

@@ -0,0 +1,76 @@
import io.netty.channel.*;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.*;
import io.netty.handler.codec.http.*;
import io.netty.handler.codec.http2.*;
import java.util.List;
class Test {
static <T> T source() { return null; }
static void sink(Object s) {}
class A extends ChannelInboundHandlerAdapter {
public void channelRead(ChannelHandlerContext ctx, Object msg) {
sink(msg); // $hasTaintFlow
}
}
class B extends ChannelInboundHandlerAdapter {
public void channelRead(ChannelHandlerContext ctx, Object msg) {
ByteBuf bb = (ByteBuf) msg;
byte[] data = new byte[1024];
bb.readBytes(data);
sink(data); // $hasTaintFlow
}
}
void test(ByteBuf bb, byte[] x) {
byte[] src = source();
bb.readBytes(x).setLong(3, 4).readerIndex(2).writeBytes(src).skipBytes(2);
sink(bb); // $ hasTaintFlow
sink(x);
}
class C extends ByteToMessageDecoder {
public void callDecode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) {
sink(msg); // $ hasTaintFlow
}
public void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) {
sink(msg); // $ hasTaintFlow
}
public void decodeLast(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) {
sink(msg); // $ hasTaintFlow
}
}
class D extends SimpleChannelInboundHandler<FullHttpRequest> {
public void channelRead0(ChannelHandlerContext ctx, FullHttpRequest msg) {
sink(msg.uri()); // $ hasTaintFlow
sink(msg.headers().get("X-blah")); // $ hasTaintFlow
sink(msg.content()); // $ hasTaintFlow
}
}
class E extends Http2FrameAdapter {
public int onDataRead(ChannelHandlerContext ctx, int streamId, ByteBuf data, int padding, boolean endOfStream) {
sink(data); // $ hasTaintFlow
return 0;
}
public void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int padding, boolean endStream) {
sink(headers.get("X-blah")); // $ hasTaintFlow
sink(headers.path()); // $ hasTaintFlow
}
public void onPushPromiseRead(ChannelHandlerContext ctx, int streamId, int promisedStreamId, Http2Headers headers, int padding) {
sink(headers); // $ hasTaintFlow
}
public void onUnknownFrame(ChannelHandlerContext ctx, byte frameType, int streamId, Http2Flags flags, ByteBuf payload) {
sink(payload); // $ hasTaintFlow
}
}
}

1
java/ql/test/library-tests/frameworks/netty/manual/options Normal file
View File

@@ -0,0 +1 @@
//semmle-extractor-options: --javac-args -cp ${testdir}/../../../../stubs/netty-4.1.x

0
java/ql/test/library-tests/frameworks/netty/manual/test.expected Normal file
View File

15
java/ql/test/library-tests/frameworks/netty/manual/test.ql Normal file
View File

@@ -0,0 +1,15 @@
import java
import semmle.code.java.dataflow.FlowSources
import TestUtilities.InlineFlowTest
class Conf extends DefaultTaintFlowConf {
override predicate isSource(DataFlow::Node node) {
super.isSource(node)
or
node instanceof RemoteFlowSource
}
}
class LegacyConfig extends EnableLegacyConfiguration {
LegacyConfig() { this instanceof Unit }
}

199
java/ql/test/stubs/netty-4.1.x/io/netty/buffer/AbstractByteBuf.java generated Normal file
View File

@@ -0,0 +1,199 @@
// Generated automatically from io.netty.buffer.AbstractByteBuf for testing purposes
package io.netty.buffer;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.SwappedByteBuf;
import io.netty.util.ByteProcessor;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.FileChannel;
import java.nio.channels.GatheringByteChannel;
import java.nio.channels.ScatteringByteChannel;
import java.nio.charset.Charset;
abstract public class AbstractByteBuf extends ByteBuf
{
protected AbstractByteBuf() {}
protected AbstractByteBuf(int p0){}
protected SwappedByteBuf newSwappedByteBuf(){ return null; }
protected abstract byte _getByte(int p0);
protected abstract int _getInt(int p0);
protected abstract int _getIntLE(int p0);
protected abstract int _getUnsignedMedium(int p0);
protected abstract int _getUnsignedMediumLE(int p0);
protected abstract long _getLong(int p0);
protected abstract long _getLongLE(int p0);
protected abstract short _getShort(int p0);
protected abstract short _getShortLE(int p0);
protected abstract void _setByte(int p0, int p1);
protected abstract void _setInt(int p0, int p1);
protected abstract void _setIntLE(int p0, int p1);
protected abstract void _setLong(int p0, long p1);
protected abstract void _setLongLE(int p0, long p1);
protected abstract void _setMedium(int p0, int p1);
protected abstract void _setMediumLE(int p0, int p1);
protected abstract void _setShort(int p0, int p1);
protected abstract void _setShortLE(int p0, int p1);
protected final void adjustMarkers(int p0){}
protected final void checkDstIndex(int p0, int p1, int p2){}
protected final void checkDstIndex(int p0, int p1, int p2, int p3){}
protected final void checkIndex(int p0){}
protected final void checkIndex(int p0, int p1){}
protected final void checkNewCapacity(int p0){}
protected final void checkReadableBytes(int p0){}
protected final void checkSrcIndex(int p0, int p1, int p2, int p3){}
protected final void ensureAccessible(){}
protected final void maxCapacity(int p0){}
protected final void trimIndicesToCapacity(int p0){}
public ByteBuf asReadOnly(){ return null; }
public ByteBuf clear(){ return null; }
public ByteBuf copy(){ return null; }
public ByteBuf discardReadBytes(){ return null; }
public ByteBuf discardSomeReadBytes(){ return null; }
public ByteBuf duplicate(){ return null; }
public ByteBuf ensureWritable(int p0){ return null; }
public ByteBuf getBytes(int p0, ByteBuf p1){ return null; }
public ByteBuf getBytes(int p0, ByteBuf p1, int p2){ return null; }
public ByteBuf getBytes(int p0, byte[] p1){ return null; }
public ByteBuf markReaderIndex(){ return null; }
public ByteBuf markWriterIndex(){ return null; }
public ByteBuf order(ByteOrder p0){ return null; }
public ByteBuf readBytes(ByteBuf p0){ return null; }
public ByteBuf readBytes(ByteBuf p0, int p1){ return null; }
public ByteBuf readBytes(ByteBuf p0, int p1, int p2){ return null; }
public ByteBuf readBytes(ByteBuffer p0){ return null; }
public ByteBuf readBytes(OutputStream p0, int p1){ return null; }
public ByteBuf readBytes(byte[] p0){ return null; }
public ByteBuf readBytes(byte[] p0, int p1, int p2){ return null; }
public ByteBuf readBytes(int p0){ return null; }
public ByteBuf readRetainedSlice(int p0){ return null; }
public ByteBuf readSlice(int p0){ return null; }
public ByteBuf readerIndex(int p0){ return null; }
public ByteBuf resetReaderIndex(){ return null; }
public ByteBuf resetWriterIndex(){ return null; }
public ByteBuf retainedDuplicate(){ return null; }
public ByteBuf retainedSlice(){ return null; }
public ByteBuf retainedSlice(int p0, int p1){ return null; }
public ByteBuf setBoolean(int p0, boolean p1){ return null; }
public ByteBuf setByte(int p0, int p1){ return null; }
public ByteBuf setBytes(int p0, ByteBuf p1){ return null; }
public ByteBuf setBytes(int p0, ByteBuf p1, int p2){ return null; }
public ByteBuf setBytes(int p0, byte[] p1){ return null; }
public ByteBuf setChar(int p0, int p1){ return null; }
public ByteBuf setDouble(int p0, double p1){ return null; }
public ByteBuf setFloat(int p0, float p1){ return null; }
public ByteBuf setIndex(int p0, int p1){ return null; }
public ByteBuf setInt(int p0, int p1){ return null; }
public ByteBuf setIntLE(int p0, int p1){ return null; }
public ByteBuf setLong(int p0, long p1){ return null; }
public ByteBuf setLongLE(int p0, long p1){ return null; }
public ByteBuf setMedium(int p0, int p1){ return null; }
public ByteBuf setMediumLE(int p0, int p1){ return null; }
public ByteBuf setShort(int p0, int p1){ return null; }
public ByteBuf setShortLE(int p0, int p1){ return null; }
public ByteBuf setZero(int p0, int p1){ return null; }
public ByteBuf skipBytes(int p0){ return null; }
public ByteBuf slice(){ return null; }
public ByteBuf slice(int p0, int p1){ return null; }
public ByteBuf writeBoolean(boolean p0){ return null; }
public ByteBuf writeByte(int p0){ return null; }
public ByteBuf writeBytes(ByteBuf p0){ return null; }
public ByteBuf writeBytes(ByteBuf p0, int p1){ return null; }
public ByteBuf writeBytes(ByteBuf p0, int p1, int p2){ return null; }
public ByteBuf writeBytes(ByteBuffer p0){ return null; }
public ByteBuf writeBytes(byte[] p0){ return null; }
public ByteBuf writeBytes(byte[] p0, int p1, int p2){ return null; }
public ByteBuf writeChar(int p0){ return null; }
public ByteBuf writeDouble(double p0){ return null; }
public ByteBuf writeFloat(float p0){ return null; }
public ByteBuf writeInt(int p0){ return null; }
public ByteBuf writeIntLE(int p0){ return null; }
public ByteBuf writeLong(long p0){ return null; }
public ByteBuf writeLongLE(long p0){ return null; }
public ByteBuf writeMedium(int p0){ return null; }
public ByteBuf writeMediumLE(int p0){ return null; }
public ByteBuf writeShort(int p0){ return null; }
public ByteBuf writeShortLE(int p0){ return null; }
public ByteBuf writeZero(int p0){ return null; }
public ByteBuf writerIndex(int p0){ return null; }
public ByteBuffer nioBuffer(){ return null; }
public ByteBuffer[] nioBuffers(){ return null; }
public CharSequence getCharSequence(int p0, int p1, Charset p2){ return null; }
public CharSequence readCharSequence(int p0, Charset p1){ return null; }
public String toString(){ return null; }
public String toString(Charset p0){ return null; }
public String toString(int p0, int p1, Charset p2){ return null; }
public boolean equals(Object p0){ return false; }
public boolean getBoolean(int p0){ return false; }
public boolean isReadOnly(){ return false; }
public boolean isReadable(){ return false; }
public boolean isReadable(int p0){ return false; }
public boolean isWritable(){ return false; }
public boolean isWritable(int p0){ return false; }
public boolean readBoolean(){ return false; }
public byte getByte(int p0){ return 0; }
public byte readByte(){ return 0; }
public char getChar(int p0){ return '0'; }
public char readChar(){ return '0'; }
public double getDouble(int p0){ return 0; }
public double readDouble(){ return 0; }
public float getFloat(int p0){ return 0; }
public float readFloat(){ return 0; }
public int bytesBefore(byte p0){ return 0; }
public int bytesBefore(int p0, byte p1){ return 0; }
public int bytesBefore(int p0, int p1, byte p2){ return 0; }
public int compareTo(ByteBuf p0){ return 0; }
public int ensureWritable(int p0, boolean p1){ return 0; }
public int forEachByte(ByteProcessor p0){ return 0; }
public int forEachByte(int p0, int p1, ByteProcessor p2){ return 0; }
public int forEachByteDesc(ByteProcessor p0){ return 0; }
public int forEachByteDesc(int p0, int p1, ByteProcessor p2){ return 0; }
public int getInt(int p0){ return 0; }
public int getIntLE(int p0){ return 0; }
public int getMedium(int p0){ return 0; }
public int getMediumLE(int p0){ return 0; }
public int getUnsignedMedium(int p0){ return 0; }
public int getUnsignedMediumLE(int p0){ return 0; }
public int getUnsignedShort(int p0){ return 0; }
public int getUnsignedShortLE(int p0){ return 0; }
public int hashCode(){ return 0; }
public int indexOf(int p0, int p1, byte p2){ return 0; }
public int maxCapacity(){ return 0; }
public int maxWritableBytes(){ return 0; }
public int readBytes(FileChannel p0, long p1, int p2){ return 0; }
public int readBytes(GatheringByteChannel p0, int p1){ return 0; }
public int readInt(){ return 0; }
public int readIntLE(){ return 0; }
public int readMedium(){ return 0; }
public int readMediumLE(){ return 0; }
public int readUnsignedMedium(){ return 0; }
public int readUnsignedMediumLE(){ return 0; }
public int readUnsignedShort(){ return 0; }
public int readUnsignedShortLE(){ return 0; }
public int readableBytes(){ return 0; }
public int readerIndex(){ return 0; }
public int setCharSequence(int p0, CharSequence p1, Charset p2){ return 0; }
public int writableBytes(){ return 0; }
public int writeBytes(FileChannel p0, long p1, int p2){ return 0; }
public int writeBytes(InputStream p0, int p1){ return 0; }
public int writeBytes(ScatteringByteChannel p0, int p1){ return 0; }
public int writeCharSequence(CharSequence p0, Charset p1){ return 0; }
public int writerIndex(){ return 0; }
public long getLong(int p0){ return 0; }
public long getLongLE(int p0){ return 0; }
public long getUnsignedInt(int p0){ return 0; }
public long getUnsignedIntLE(int p0){ return 0; }
public long readLong(){ return 0; }
public long readLongLE(){ return 0; }
public long readUnsignedInt(){ return 0; }
public long readUnsignedIntLE(){ return 0; }
public short getShort(int p0){ return 0; }
public short getShortLE(int p0){ return 0; }
public short getUnsignedByte(int p0){ return 0; }
public short readShort(){ return 0; }
public short readShortLE(){ return 0; }
public short readUnsignedByte(){ return 0; }
}

22
java/ql/test/stubs/netty-4.1.x/io/netty/buffer/AbstractReferenceCountedByteBuf.java generated Normal file
View File

@@ -0,0 +1,22 @@
// Generated automatically from io.netty.buffer.AbstractReferenceCountedByteBuf for testing purposes
package io.netty.buffer;
import io.netty.buffer.AbstractByteBuf;
import io.netty.buffer.ByteBuf;
abstract public class AbstractReferenceCountedByteBuf extends AbstractByteBuf
{
protected AbstractReferenceCountedByteBuf() {}
protected AbstractReferenceCountedByteBuf(int p0){}
protected abstract void deallocate();
protected final void resetRefCnt(){}
protected final void setRefCnt(int p0){}
public ByteBuf retain(){ return null; }
public ByteBuf retain(int p0){ return null; }
public ByteBuf touch(){ return null; }
public ByteBuf touch(Object p0){ return null; }
public boolean release(){ return false; }
public boolean release(int p0){ return false; }
public int refCnt(){ return 0; }
}

227
java/ql/test/stubs/netty-4.1.x/io/netty/buffer/ByteBuf.java generated
View File

@@ -1,19 +1,212 @@
/*
* Copyright 2012 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
// Generated automatically from io.netty.buffer.ByteBuf for testing purposes
package io.netty.buffer;
public abstract class ByteBuf implements Comparable<ByteBuf> {
}
import io.netty.buffer.ByteBufAllocator;
import io.netty.buffer.ByteBufConvertible;
import io.netty.util.ByteProcessor;
import io.netty.util.ReferenceCounted;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.FileChannel;
import java.nio.channels.GatheringByteChannel;
import java.nio.channels.ScatteringByteChannel;
import java.nio.charset.Charset;
abstract public class ByteBuf implements ByteBufConvertible, Comparable<ByteBuf>, ReferenceCounted
{
public ByteBuf asByteBuf(){ return null; }
public ByteBuf setDoubleLE(int p0, double p1){ return null; }
public ByteBuf setFloatLE(int p0, float p1){ return null; }
public ByteBuf writeDoubleLE(double p0){ return null; }
public ByteBuf writeFloatLE(float p0){ return null; }
public ByteBuf(){}
public abstract ByteBuf asReadOnly();
public abstract ByteBuf capacity(int p0);
public abstract ByteBuf clear();
public abstract ByteBuf copy();
public abstract ByteBuf copy(int p0, int p1);
public abstract ByteBuf discardReadBytes();
public abstract ByteBuf discardSomeReadBytes();
public abstract ByteBuf duplicate();
public abstract ByteBuf ensureWritable(int p0);
public abstract ByteBuf getBytes(int p0, ByteBuf p1);
public abstract ByteBuf getBytes(int p0, ByteBuf p1, int p2);
public abstract ByteBuf getBytes(int p0, ByteBuf p1, int p2, int p3);
public abstract ByteBuf getBytes(int p0, ByteBuffer p1);
public abstract ByteBuf getBytes(int p0, OutputStream p1, int p2);
public abstract ByteBuf getBytes(int p0, byte[] p1);
public abstract ByteBuf getBytes(int p0, byte[] p1, int p2, int p3);
public abstract ByteBuf markReaderIndex();
public abstract ByteBuf markWriterIndex();
public abstract ByteBuf order(ByteOrder p0);
public abstract ByteBuf readBytes(ByteBuf p0);
public abstract ByteBuf readBytes(ByteBuf p0, int p1);
public abstract ByteBuf readBytes(ByteBuf p0, int p1, int p2);
public abstract ByteBuf readBytes(ByteBuffer p0);
public abstract ByteBuf readBytes(OutputStream p0, int p1);
public abstract ByteBuf readBytes(byte[] p0);
public abstract ByteBuf readBytes(byte[] p0, int p1, int p2);
public abstract ByteBuf readBytes(int p0);
public abstract ByteBuf readRetainedSlice(int p0);
public abstract ByteBuf readSlice(int p0);
public abstract ByteBuf readerIndex(int p0);
public abstract ByteBuf resetReaderIndex();
public abstract ByteBuf resetWriterIndex();
public abstract ByteBuf retain();
public abstract ByteBuf retain(int p0);
public abstract ByteBuf retainedDuplicate();
public abstract ByteBuf retainedSlice();
public abstract ByteBuf retainedSlice(int p0, int p1);
public abstract ByteBuf setBoolean(int p0, boolean p1);
public abstract ByteBuf setByte(int p0, int p1);
public abstract ByteBuf setBytes(int p0, ByteBuf p1);
public abstract ByteBuf setBytes(int p0, ByteBuf p1, int p2);
public abstract ByteBuf setBytes(int p0, ByteBuf p1, int p2, int p3);
public abstract ByteBuf setBytes(int p0, ByteBuffer p1);
public abstract ByteBuf setBytes(int p0, byte[] p1);
public abstract ByteBuf setBytes(int p0, byte[] p1, int p2, int p3);
public abstract ByteBuf setChar(int p0, int p1);
public abstract ByteBuf setDouble(int p0, double p1);
public abstract ByteBuf setFloat(int p0, float p1);
public abstract ByteBuf setIndex(int p0, int p1);
public abstract ByteBuf setInt(int p0, int p1);
public abstract ByteBuf setIntLE(int p0, int p1);
public abstract ByteBuf setLong(int p0, long p1);
public abstract ByteBuf setLongLE(int p0, long p1);
public abstract ByteBuf setMedium(int p0, int p1);
public abstract ByteBuf setMediumLE(int p0, int p1);
public abstract ByteBuf setShort(int p0, int p1);
public abstract ByteBuf setShortLE(int p0, int p1);
public abstract ByteBuf setZero(int p0, int p1);
public abstract ByteBuf skipBytes(int p0);
public abstract ByteBuf slice();
public abstract ByteBuf slice(int p0, int p1);
public abstract ByteBuf touch();
public abstract ByteBuf touch(Object p0);
public abstract ByteBuf unwrap();
public abstract ByteBuf writeBoolean(boolean p0);
public abstract ByteBuf writeByte(int p0);
public abstract ByteBuf writeBytes(ByteBuf p0);
public abstract ByteBuf writeBytes(ByteBuf p0, int p1);
public abstract ByteBuf writeBytes(ByteBuf p0, int p1, int p2);
public abstract ByteBuf writeBytes(ByteBuffer p0);
public abstract ByteBuf writeBytes(byte[] p0);
public abstract ByteBuf writeBytes(byte[] p0, int p1, int p2);
public abstract ByteBuf writeChar(int p0);
public abstract ByteBuf writeDouble(double p0);
public abstract ByteBuf writeFloat(float p0);
public abstract ByteBuf writeInt(int p0);
public abstract ByteBuf writeIntLE(int p0);
public abstract ByteBuf writeLong(long p0);
public abstract ByteBuf writeLongLE(long p0);
public abstract ByteBuf writeMedium(int p0);
public abstract ByteBuf writeMediumLE(int p0);
public abstract ByteBuf writeShort(int p0);
public abstract ByteBuf writeShortLE(int p0);
public abstract ByteBuf writeZero(int p0);
public abstract ByteBuf writerIndex(int p0);
public abstract ByteBufAllocator alloc();
public abstract ByteBuffer internalNioBuffer(int p0, int p1);
public abstract ByteBuffer nioBuffer();
public abstract ByteBuffer nioBuffer(int p0, int p1);
public abstract ByteBuffer[] nioBuffers();
public abstract ByteBuffer[] nioBuffers(int p0, int p1);
public abstract ByteOrder order();
public abstract CharSequence getCharSequence(int p0, int p1, Charset p2);
public abstract CharSequence readCharSequence(int p0, Charset p1);
public abstract String toString();
public abstract String toString(Charset p0);
public abstract String toString(int p0, int p1, Charset p2);
public abstract boolean equals(Object p0);
public abstract boolean getBoolean(int p0);
public abstract boolean hasArray();
public abstract boolean hasMemoryAddress();
public abstract boolean isDirect();
public abstract boolean isReadOnly();
public abstract boolean isReadable();
public abstract boolean isReadable(int p0);
public abstract boolean isWritable();
public abstract boolean isWritable(int p0);
public abstract boolean readBoolean();
public abstract byte getByte(int p0);
public abstract byte readByte();
public abstract byte[] array();
public abstract char getChar(int p0);
public abstract char readChar();
public abstract double getDouble(int p0);
public abstract double readDouble();
public abstract float getFloat(int p0);
public abstract float readFloat();
public abstract int arrayOffset();
public abstract int bytesBefore(byte p0);
public abstract int bytesBefore(int p0, byte p1);
public abstract int bytesBefore(int p0, int p1, byte p2);
public abstract int capacity();
public abstract int compareTo(ByteBuf p0);
public abstract int ensureWritable(int p0, boolean p1);
public abstract int forEachByte(ByteProcessor p0);
public abstract int forEachByte(int p0, int p1, ByteProcessor p2);
public abstract int forEachByteDesc(ByteProcessor p0);
public abstract int forEachByteDesc(int p0, int p1, ByteProcessor p2);
public abstract int getBytes(int p0, FileChannel p1, long p2, int p3);
public abstract int getBytes(int p0, GatheringByteChannel p1, int p2);
public abstract int getInt(int p0);
public abstract int getIntLE(int p0);
public abstract int getMedium(int p0);
public abstract int getMediumLE(int p0);
public abstract int getUnsignedMedium(int p0);
public abstract int getUnsignedMediumLE(int p0);
public abstract int getUnsignedShort(int p0);
public abstract int getUnsignedShortLE(int p0);
public abstract int hashCode();
public abstract int indexOf(int p0, int p1, byte p2);
public abstract int maxCapacity();
public abstract int maxWritableBytes();
public abstract int nioBufferCount();
public abstract int readBytes(FileChannel p0, long p1, int p2);
public abstract int readBytes(GatheringByteChannel p0, int p1);
public abstract int readInt();
public abstract int readIntLE();
public abstract int readMedium();
public abstract int readMediumLE();
public abstract int readUnsignedMedium();
public abstract int readUnsignedMediumLE();
public abstract int readUnsignedShort();
public abstract int readUnsignedShortLE();
public abstract int readableBytes();
public abstract int readerIndex();
public abstract int setBytes(int p0, FileChannel p1, long p2, int p3);
public abstract int setBytes(int p0, InputStream p1, int p2);
public abstract int setBytes(int p0, ScatteringByteChannel p1, int p2);
public abstract int setCharSequence(int p0, CharSequence p1, Charset p2);
public abstract int writableBytes();
public abstract int writeBytes(FileChannel p0, long p1, int p2);
public abstract int writeBytes(InputStream p0, int p1);
public abstract int writeBytes(ScatteringByteChannel p0, int p1);
public abstract int writeCharSequence(CharSequence p0, Charset p1);
public abstract int writerIndex();
public abstract long getLong(int p0);
public abstract long getLongLE(int p0);
public abstract long getUnsignedInt(int p0);
public abstract long getUnsignedIntLE(int p0);
public abstract long memoryAddress();
public abstract long readLong();
public abstract long readLongLE();
public abstract long readUnsignedInt();
public abstract long readUnsignedIntLE();
public abstract short getShort(int p0);
public abstract short getShortLE(int p0);
public abstract short getUnsignedByte(int p0);
public abstract short readShort();
public abstract short readShortLE();
public abstract short readUnsignedByte();
public boolean isContiguous(){ return false; }
public double getDoubleLE(int p0){ return 0; }
public double readDoubleLE(){ return 0; }
public float getFloatLE(int p0){ return 0; }
public float readFloatLE(){ return 0; }
public int maxFastWritableBytes(){ return 0; }
}

31
java/ql/test/stubs/netty-4.1.x/io/netty/buffer/ByteBufAllocator.java generated Normal file
View File

@@ -0,0 +1,31 @@
// Generated automatically from io.netty.buffer.ByteBufAllocator for testing purposes
package io.netty.buffer;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.CompositeByteBuf;
public interface ByteBufAllocator
{
ByteBuf buffer();
ByteBuf buffer(int p0);
ByteBuf buffer(int p0, int p1);
ByteBuf directBuffer();
ByteBuf directBuffer(int p0);
ByteBuf directBuffer(int p0, int p1);
ByteBuf heapBuffer();
ByteBuf heapBuffer(int p0);
ByteBuf heapBuffer(int p0, int p1);
ByteBuf ioBuffer();
ByteBuf ioBuffer(int p0);
ByteBuf ioBuffer(int p0, int p1);
CompositeByteBuf compositeBuffer();
CompositeByteBuf compositeBuffer(int p0);
CompositeByteBuf compositeDirectBuffer();
CompositeByteBuf compositeDirectBuffer(int p0);
CompositeByteBuf compositeHeapBuffer();
CompositeByteBuf compositeHeapBuffer(int p0);
boolean isDirectBufferPooled();
int calculateNewCapacity(int p0, int p1);
static ByteBufAllocator DEFAULT = null;
}

10
java/ql/test/stubs/netty-4.1.x/io/netty/buffer/ByteBufConvertible.java generated Normal file
View File

@@ -0,0 +1,10 @@
// Generated automatically from io.netty.buffer.ByteBufConvertible for testing purposes
package io.netty.buffer;
import io.netty.buffer.ByteBuf;
public interface ByteBufConvertible
{
ByteBuf asByteBuf();
}

19
java/ql/test/stubs/netty-4.1.x/io/netty/buffer/ByteBufHolder.java generated Normal file
View File

@@ -0,0 +1,19 @@
// Generated automatically from io.netty.buffer.ByteBufHolder for testing purposes
package io.netty.buffer;
import io.netty.buffer.ByteBuf;
import io.netty.util.ReferenceCounted;
public interface ByteBufHolder extends ReferenceCounted
{
ByteBuf content();
ByteBufHolder copy();
ByteBufHolder duplicate();
ByteBufHolder replace(ByteBuf p0);
ByteBufHolder retain();
ByteBufHolder retain(int p0);
ByteBufHolder retainedDuplicate();
ByteBufHolder touch();
ByteBufHolder touch(Object p0);
}

40
java/ql/test/stubs/netty-4.1.x/io/netty/buffer/ByteBufInputStream.java generated Normal file
View File

@@ -0,0 +1,40 @@
// Generated automatically from io.netty.buffer.ByteBufInputStream for testing purposes
package io.netty.buffer;
import io.netty.buffer.ByteBuf;
import java.io.DataInput;
import java.io.InputStream;
public class ByteBufInputStream extends InputStream implements DataInput
{
protected ByteBufInputStream() {}
public ByteBufInputStream(ByteBuf p0){}
public ByteBufInputStream(ByteBuf p0, boolean p1){}
public ByteBufInputStream(ByteBuf p0, int p1){}
public ByteBufInputStream(ByteBuf p0, int p1, boolean p2){}
public String readLine(){ return null; }
public String readUTF(){ return null; }
public boolean markSupported(){ return false; }
public boolean readBoolean(){ return false; }
public byte readByte(){ return 0; }
public char readChar(){ return '0'; }
public double readDouble(){ return 0; }
public float readFloat(){ return 0; }
public int available(){ return 0; }
public int read(){ return 0; }
public int read(byte[] p0, int p1, int p2){ return 0; }
public int readBytes(){ return 0; }
public int readInt(){ return 0; }
public int readUnsignedByte(){ return 0; }
public int readUnsignedShort(){ return 0; }
public int skipBytes(int p0){ return 0; }
public long readLong(){ return 0; }
public long skip(long p0){ return 0; }
public short readShort(){ return 0; }
public void close(){}
public void mark(int p0){}
public void readFully(byte[] p0){}
public void readFully(byte[] p0, int p1, int p2){}
public void reset(){}
}

30
java/ql/test/stubs/netty-4.1.x/io/netty/buffer/ByteBufOutputStream.java generated Normal file
View File

@@ -0,0 +1,30 @@
// Generated automatically from io.netty.buffer.ByteBufOutputStream for testing purposes
package io.netty.buffer;
import io.netty.buffer.ByteBuf;
import java.io.DataOutput;
import java.io.OutputStream;
public class ByteBufOutputStream extends OutputStream implements DataOutput
{
protected ByteBufOutputStream() {}
public ByteBuf buffer(){ return null; }
public ByteBufOutputStream(ByteBuf p0){}
public int writtenBytes(){ return 0; }
public void close(){}
public void write(byte[] p0){}
public void write(byte[] p0, int p1, int p2){}
public void write(int p0){}
public void writeBoolean(boolean p0){}
public void writeByte(int p0){}
public void writeBytes(String p0){}
public void writeChar(int p0){}
public void writeChars(String p0){}
public void writeDouble(double p0){}
public void writeFloat(float p0){}
public void writeInt(int p0){}
public void writeLong(long p0){}
public void writeShort(int p0){}
public void writeUTF(String p0){}
}

64
java/ql/test/stubs/netty-4.1.x/io/netty/buffer/ByteBufUtil.java generated Normal file
View File

@@ -0,0 +1,64 @@
// Generated automatically from io.netty.buffer.ByteBufUtil for testing purposes
package io.netty.buffer;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.util.AsciiString;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
public class ByteBufUtil
{
protected ByteBufUtil() {}
public static ByteBuf encodeString(ByteBufAllocator p0, CharBuffer p1, Charset p2){ return null; }
public static ByteBuf encodeString(ByteBufAllocator p0, CharBuffer p1, Charset p2, int p3){ return null; }
public static ByteBuf ensureAccessible(ByteBuf p0){ return null; }
public static ByteBuf readBytes(ByteBufAllocator p0, ByteBuf p1, int p2){ return null; }
public static ByteBuf setShortBE(ByteBuf p0, int p1, int p2){ return null; }
public static ByteBuf threadLocalDirectBuffer(){ return null; }
public static ByteBuf writeAscii(ByteBufAllocator p0, CharSequence p1){ return null; }
public static ByteBuf writeMediumBE(ByteBuf p0, int p1){ return null; }
public static ByteBuf writeShortBE(ByteBuf p0, int p1){ return null; }
public static ByteBuf writeUtf8(ByteBufAllocator p0, CharSequence p1){ return null; }
public static String hexDump(ByteBuf p0){ return null; }
public static String hexDump(ByteBuf p0, int p1, int p2){ return null; }
public static String hexDump(byte[] p0){ return null; }
public static String hexDump(byte[] p0, int p1, int p2){ return null; }
public static String prettyHexDump(ByteBuf p0){ return null; }
public static String prettyHexDump(ByteBuf p0, int p1, int p2){ return null; }
public static boolean ensureWritableSuccess(int p0){ return false; }
public static boolean equals(ByteBuf p0, ByteBuf p1){ return false; }
public static boolean equals(ByteBuf p0, int p1, ByteBuf p2, int p3, int p4){ return false; }
public static boolean isAccessible(ByteBuf p0){ return false; }
public static boolean isText(ByteBuf p0, Charset p1){ return false; }
public static boolean isText(ByteBuf p0, int p1, int p2, Charset p3){ return false; }
public static byte decodeHexByte(CharSequence p0, int p1){ return 0; }
public static byte[] decodeHexDump(CharSequence p0){ return null; }
public static byte[] decodeHexDump(CharSequence p0, int p1, int p2){ return null; }
public static byte[] getBytes(ByteBuf p0){ return null; }
public static byte[] getBytes(ByteBuf p0, int p1, int p2){ return null; }
public static byte[] getBytes(ByteBuf p0, int p1, int p2, boolean p3){ return null; }
public static int compare(ByteBuf p0, ByteBuf p1){ return 0; }
public static int hashCode(ByteBuf p0){ return 0; }
public static int indexOf(ByteBuf p0, ByteBuf p1){ return 0; }
public static int indexOf(ByteBuf p0, int p1, int p2, byte p3){ return 0; }
public static int reserveAndWriteUtf8(ByteBuf p0, CharSequence p1, int p2){ return 0; }
public static int reserveAndWriteUtf8(ByteBuf p0, CharSequence p1, int p2, int p3, int p4){ return 0; }
public static int swapInt(int p0){ return 0; }
public static int swapMedium(int p0){ return 0; }
public static int utf8Bytes(CharSequence p0){ return 0; }
public static int utf8Bytes(CharSequence p0, int p1, int p2){ return 0; }
public static int utf8MaxBytes(CharSequence p0){ return 0; }
public static int utf8MaxBytes(int p0){ return 0; }
public static int writeAscii(ByteBuf p0, CharSequence p1){ return 0; }
public static int writeUtf8(ByteBuf p0, CharSequence p1){ return 0; }
public static int writeUtf8(ByteBuf p0, CharSequence p1, int p2, int p3){ return 0; }
public static long swapLong(long p0){ return 0; }
public static short swapShort(short p0){ return 0; }
public static void appendPrettyHexDump(StringBuilder p0, ByteBuf p1){}
public static void appendPrettyHexDump(StringBuilder p0, ByteBuf p1, int p2, int p3){}
public static void copy(AsciiString p0, ByteBuf p1){}
public static void copy(AsciiString p0, int p1, ByteBuf p2, int p3){}
public static void copy(AsciiString p0, int p1, ByteBuf p2, int p3, int p4){}
}

158
java/ql/test/stubs/netty-4.1.x/io/netty/buffer/CompositeByteBuf.java generated Normal file
View File

@@ -0,0 +1,158 @@
// Generated automatically from io.netty.buffer.CompositeByteBuf for testing purposes
package io.netty.buffer;
import io.netty.buffer.AbstractReferenceCountedByteBuf;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.util.ByteProcessor;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.FileChannel;
import java.nio.channels.GatheringByteChannel;
import java.nio.channels.ScatteringByteChannel;
import java.util.Iterator;
import java.util.List;
public class CompositeByteBuf extends AbstractReferenceCountedByteBuf implements Iterable<ByteBuf>
{
protected CompositeByteBuf() {}
protected byte _getByte(int p0){ return 0; }
protected int _getInt(int p0){ return 0; }
protected int _getIntLE(int p0){ return 0; }
protected int _getUnsignedMedium(int p0){ return 0; }
protected int _getUnsignedMediumLE(int p0){ return 0; }
protected int forEachByteAsc0(int p0, int p1, ByteProcessor p2){ return 0; }
protected int forEachByteDesc0(int p0, int p1, ByteProcessor p2){ return 0; }
protected long _getLong(int p0){ return 0; }
protected long _getLongLE(int p0){ return 0; }
protected short _getShort(int p0){ return 0; }
protected short _getShortLE(int p0){ return 0; }
protected void _setByte(int p0, int p1){}
protected void _setInt(int p0, int p1){}
protected void _setIntLE(int p0, int p1){}
protected void _setLong(int p0, long p1){}
protected void _setLongLE(int p0, long p1){}
protected void _setMedium(int p0, int p1){}
protected void _setMediumLE(int p0, int p1){}
protected void _setShort(int p0, int p1){}
protected void _setShortLE(int p0, int p1){}
protected void deallocate(){}
public ByteBuf component(int p0){ return null; }
public ByteBuf componentAtOffset(int p0){ return null; }
public ByteBuf copy(int p0, int p1){ return null; }
public ByteBuf internalComponent(int p0){ return null; }
public ByteBuf internalComponentAtOffset(int p0){ return null; }
public ByteBuf unwrap(){ return null; }
public ByteBufAllocator alloc(){ return null; }
public ByteBuffer internalNioBuffer(int p0, int p1){ return null; }
public ByteBuffer nioBuffer(int p0, int p1){ return null; }
public ByteBuffer[] nioBuffers(){ return null; }
public ByteBuffer[] nioBuffers(int p0, int p1){ return null; }
public ByteOrder order(){ return null; }
public CompositeByteBuf addComponent(ByteBuf p0){ return null; }
public CompositeByteBuf addComponent(boolean p0, ByteBuf p1){ return null; }
public CompositeByteBuf addComponent(boolean p0, int p1, ByteBuf p2){ return null; }
public CompositeByteBuf addComponent(int p0, ByteBuf p1){ return null; }
public CompositeByteBuf addComponents(ByteBuf... p0){ return null; }
public CompositeByteBuf addComponents(Iterable<ByteBuf> p0){ return null; }
public CompositeByteBuf addComponents(boolean p0, ByteBuf... p1){ return null; }
public CompositeByteBuf addComponents(boolean p0, Iterable<ByteBuf> p1){ return null; }
public CompositeByteBuf addComponents(int p0, ByteBuf... p1){ return null; }
public CompositeByteBuf addComponents(int p0, Iterable<ByteBuf> p1){ return null; }
public CompositeByteBuf addFlattenedComponents(boolean p0, ByteBuf p1){ return null; }
public CompositeByteBuf capacity(int p0){ return null; }
public CompositeByteBuf clear(){ return null; }
public CompositeByteBuf consolidate(){ return null; }
public CompositeByteBuf consolidate(int p0, int p1){ return null; }
public CompositeByteBuf discardReadBytes(){ return null; }
public CompositeByteBuf discardReadComponents(){ return null; }
public CompositeByteBuf discardSomeReadBytes(){ return null; }
public CompositeByteBuf ensureWritable(int p0){ return null; }
public CompositeByteBuf getBytes(int p0, ByteBuf p1){ return null; }
public CompositeByteBuf getBytes(int p0, ByteBuf p1, int p2){ return null; }
public CompositeByteBuf getBytes(int p0, ByteBuf p1, int p2, int p3){ return null; }
public CompositeByteBuf getBytes(int p0, ByteBuffer p1){ return null; }
public CompositeByteBuf getBytes(int p0, OutputStream p1, int p2){ return null; }
public CompositeByteBuf getBytes(int p0, byte[] p1){ return null; }
public CompositeByteBuf getBytes(int p0, byte[] p1, int p2, int p3){ return null; }
public CompositeByteBuf markReaderIndex(){ return null; }
public CompositeByteBuf markWriterIndex(){ return null; }
public CompositeByteBuf readBytes(ByteBuf p0){ return null; }
public CompositeByteBuf readBytes(ByteBuf p0, int p1){ return null; }
public CompositeByteBuf readBytes(ByteBuf p0, int p1, int p2){ return null; }
public CompositeByteBuf readBytes(ByteBuffer p0){ return null; }
public CompositeByteBuf readBytes(OutputStream p0, int p1){ return null; }
public CompositeByteBuf readBytes(byte[] p0){ return null; }
public CompositeByteBuf readBytes(byte[] p0, int p1, int p2){ return null; }
public CompositeByteBuf readerIndex(int p0){ return null; }
public CompositeByteBuf removeComponent(int p0){ return null; }
public CompositeByteBuf removeComponents(int p0, int p1){ return null; }
public CompositeByteBuf resetReaderIndex(){ return null; }
public CompositeByteBuf resetWriterIndex(){ return null; }
public CompositeByteBuf retain(){ return null; }
public CompositeByteBuf retain(int p0){ return null; }
public CompositeByteBuf setBoolean(int p0, boolean p1){ return null; }
public CompositeByteBuf setByte(int p0, int p1){ return null; }
public CompositeByteBuf setBytes(int p0, ByteBuf p1){ return null; }
public CompositeByteBuf setBytes(int p0, ByteBuf p1, int p2){ return null; }
public CompositeByteBuf setBytes(int p0, ByteBuf p1, int p2, int p3){ return null; }
public CompositeByteBuf setBytes(int p0, ByteBuffer p1){ return null; }
public CompositeByteBuf setBytes(int p0, byte[] p1){ return null; }
public CompositeByteBuf setBytes(int p0, byte[] p1, int p2, int p3){ return null; }
public CompositeByteBuf setChar(int p0, int p1){ return null; }
public CompositeByteBuf setDouble(int p0, double p1){ return null; }
public CompositeByteBuf setFloat(int p0, float p1){ return null; }
public CompositeByteBuf setIndex(int p0, int p1){ return null; }
public CompositeByteBuf setInt(int p0, int p1){ return null; }
public CompositeByteBuf setLong(int p0, long p1){ return null; }
public CompositeByteBuf setMedium(int p0, int p1){ return null; }
public CompositeByteBuf setShort(int p0, int p1){ return null; }
public CompositeByteBuf setZero(int p0, int p1){ return null; }
public CompositeByteBuf skipBytes(int p0){ return null; }
public CompositeByteBuf touch(){ return null; }
public CompositeByteBuf touch(Object p0){ return null; }
public CompositeByteBuf writeBoolean(boolean p0){ return null; }
public CompositeByteBuf writeByte(int p0){ return null; }
public CompositeByteBuf writeBytes(ByteBuf p0){ return null; }
public CompositeByteBuf writeBytes(ByteBuf p0, int p1){ return null; }
public CompositeByteBuf writeBytes(ByteBuf p0, int p1, int p2){ return null; }
public CompositeByteBuf writeBytes(ByteBuffer p0){ return null; }
public CompositeByteBuf writeBytes(byte[] p0){ return null; }
public CompositeByteBuf writeBytes(byte[] p0, int p1, int p2){ return null; }
public CompositeByteBuf writeChar(int p0){ return null; }
public CompositeByteBuf writeDouble(double p0){ return null; }
public CompositeByteBuf writeFloat(float p0){ return null; }
public CompositeByteBuf writeInt(int p0){ return null; }
public CompositeByteBuf writeLong(long p0){ return null; }
public CompositeByteBuf writeMedium(int p0){ return null; }
public CompositeByteBuf writeShort(int p0){ return null; }
public CompositeByteBuf writeZero(int p0){ return null; }
public CompositeByteBuf writerIndex(int p0){ return null; }
public CompositeByteBuf(ByteBufAllocator p0, boolean p1, int p2){}
public CompositeByteBuf(ByteBufAllocator p0, boolean p1, int p2, ByteBuf... p3){}
public CompositeByteBuf(ByteBufAllocator p0, boolean p1, int p2, Iterable<ByteBuf> p3){}
public Iterator<ByteBuf> iterator(){ return null; }
public List<ByteBuf> decompose(int p0, int p1){ return null; }
public String toString(){ return null; }
public boolean hasArray(){ return false; }
public boolean hasMemoryAddress(){ return false; }
public boolean isDirect(){ return false; }
public byte getByte(int p0){ return 0; }
public byte[] array(){ return null; }
public int arrayOffset(){ return 0; }
public int capacity(){ return 0; }
public int getBytes(int p0, FileChannel p1, long p2, int p3){ return 0; }
public int getBytes(int p0, GatheringByteChannel p1, int p2){ return 0; }
public int maxNumComponents(){ return 0; }
public int nioBufferCount(){ return 0; }
public int numComponents(){ return 0; }
public int setBytes(int p0, FileChannel p1, long p2, int p3){ return 0; }
public int setBytes(int p0, InputStream p1, int p2){ return 0; }
public int setBytes(int p0, ScatteringByteChannel p1, int p2){ return 0; }
public int toByteIndex(int p0){ return 0; }
public int toComponentIndex(int p0){ return 0; }
public long memoryAddress(){ return 0; }
}

28
java/ql/test/stubs/netty-4.1.x/io/netty/buffer/DefaultByteBufHolder.java generated Normal file
View File

@@ -0,0 +1,28 @@
// Generated automatically from io.netty.buffer.DefaultByteBufHolder for testing purposes
package io.netty.buffer;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufHolder;
public class DefaultByteBufHolder implements ByteBufHolder
{
protected DefaultByteBufHolder() {}
protected final String contentToString(){ return null; }
public ByteBuf content(){ return null; }
public ByteBufHolder copy(){ return null; }
public ByteBufHolder duplicate(){ return null; }
public ByteBufHolder replace(ByteBuf p0){ return null; }
public ByteBufHolder retain(){ return null; }
public ByteBufHolder retain(int p0){ return null; }
public ByteBufHolder retainedDuplicate(){ return null; }
public ByteBufHolder touch(){ return null; }
public ByteBufHolder touch(Object p0){ return null; }
public DefaultByteBufHolder(ByteBuf p0){}
public String toString(){ return null; }
public boolean equals(Object p0){ return false; }
public boolean release(){ return false; }
public boolean release(int p0){ return false; }
public int hashCode(){ return 0; }
public int refCnt(){ return 0; }
}

206
java/ql/test/stubs/netty-4.1.x/io/netty/buffer/SwappedByteBuf.java generated Normal file
View File

@@ -0,0 +1,206 @@
// Generated automatically from io.netty.buffer.SwappedByteBuf for testing purposes
package io.netty.buffer;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.util.ByteProcessor;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.FileChannel;
import java.nio.channels.GatheringByteChannel;
import java.nio.channels.ScatteringByteChannel;
import java.nio.charset.Charset;
public class SwappedByteBuf extends ByteBuf
{
protected SwappedByteBuf() {}
public ByteBuf asReadOnly(){ return null; }
public ByteBuf capacity(int p0){ return null; }
public ByteBuf clear(){ return null; }
public ByteBuf copy(){ return null; }
public ByteBuf copy(int p0, int p1){ return null; }
public ByteBuf discardReadBytes(){ return null; }
public ByteBuf discardSomeReadBytes(){ return null; }
public ByteBuf duplicate(){ return null; }
public ByteBuf ensureWritable(int p0){ return null; }
public ByteBuf getBytes(int p0, ByteBuf p1){ return null; }
public ByteBuf getBytes(int p0, ByteBuf p1, int p2){ return null; }
public ByteBuf getBytes(int p0, ByteBuf p1, int p2, int p3){ return null; }
public ByteBuf getBytes(int p0, ByteBuffer p1){ return null; }
public ByteBuf getBytes(int p0, OutputStream p1, int p2){ return null; }
public ByteBuf getBytes(int p0, byte[] p1){ return null; }
public ByteBuf getBytes(int p0, byte[] p1, int p2, int p3){ return null; }
public ByteBuf markReaderIndex(){ return null; }
public ByteBuf markWriterIndex(){ return null; }
public ByteBuf order(ByteOrder p0){ return null; }
public ByteBuf readBytes(ByteBuf p0){ return null; }
public ByteBuf readBytes(ByteBuf p0, int p1){ return null; }
public ByteBuf readBytes(ByteBuf p0, int p1, int p2){ return null; }
public ByteBuf readBytes(ByteBuffer p0){ return null; }
public ByteBuf readBytes(OutputStream p0, int p1){ return null; }
public ByteBuf readBytes(byte[] p0){ return null; }
public ByteBuf readBytes(byte[] p0, int p1, int p2){ return null; }
public ByteBuf readBytes(int p0){ return null; }
public ByteBuf readRetainedSlice(int p0){ return null; }
public ByteBuf readSlice(int p0){ return null; }
public ByteBuf readerIndex(int p0){ return null; }
public ByteBuf resetReaderIndex(){ return null; }
public ByteBuf resetWriterIndex(){ return null; }
public ByteBuf retain(){ return null; }
public ByteBuf retain(int p0){ return null; }
public ByteBuf retainedDuplicate(){ return null; }
public ByteBuf retainedSlice(){ return null; }
public ByteBuf retainedSlice(int p0, int p1){ return null; }
public ByteBuf setBoolean(int p0, boolean p1){ return null; }
public ByteBuf setByte(int p0, int p1){ return null; }
public ByteBuf setBytes(int p0, ByteBuf p1){ return null; }
public ByteBuf setBytes(int p0, ByteBuf p1, int p2){ return null; }
public ByteBuf setBytes(int p0, ByteBuf p1, int p2, int p3){ return null; }
public ByteBuf setBytes(int p0, ByteBuffer p1){ return null; }
public ByteBuf setBytes(int p0, byte[] p1){ return null; }
public ByteBuf setBytes(int p0, byte[] p1, int p2, int p3){ return null; }
public ByteBuf setChar(int p0, int p1){ return null; }
public ByteBuf setDouble(int p0, double p1){ return null; }
public ByteBuf setFloat(int p0, float p1){ return null; }
public ByteBuf setIndex(int p0, int p1){ return null; }
public ByteBuf setInt(int p0, int p1){ return null; }
public ByteBuf setIntLE(int p0, int p1){ return null; }
public ByteBuf setLong(int p0, long p1){ return null; }
public ByteBuf setLongLE(int p0, long p1){ return null; }
public ByteBuf setMedium(int p0, int p1){ return null; }
public ByteBuf setMediumLE(int p0, int p1){ return null; }
public ByteBuf setShort(int p0, int p1){ return null; }
public ByteBuf setShortLE(int p0, int p1){ return null; }
public ByteBuf setZero(int p0, int p1){ return null; }
public ByteBuf skipBytes(int p0){ return null; }
public ByteBuf slice(){ return null; }
public ByteBuf slice(int p0, int p1){ return null; }
public ByteBuf touch(){ return null; }
public ByteBuf touch(Object p0){ return null; }
public ByteBuf unwrap(){ return null; }
public ByteBuf writeBoolean(boolean p0){ return null; }
public ByteBuf writeByte(int p0){ return null; }
public ByteBuf writeBytes(ByteBuf p0){ return null; }
public ByteBuf writeBytes(ByteBuf p0, int p1){ return null; }
public ByteBuf writeBytes(ByteBuf p0, int p1, int p2){ return null; }
public ByteBuf writeBytes(ByteBuffer p0){ return null; }
public ByteBuf writeBytes(byte[] p0){ return null; }
public ByteBuf writeBytes(byte[] p0, int p1, int p2){ return null; }
public ByteBuf writeChar(int p0){ return null; }
public ByteBuf writeDouble(double p0){ return null; }
public ByteBuf writeFloat(float p0){ return null; }
public ByteBuf writeInt(int p0){ return null; }
public ByteBuf writeIntLE(int p0){ return null; }
public ByteBuf writeLong(long p0){ return null; }
public ByteBuf writeLongLE(long p0){ return null; }
public ByteBuf writeMedium(int p0){ return null; }
public ByteBuf writeMediumLE(int p0){ return null; }
public ByteBuf writeShort(int p0){ return null; }
public ByteBuf writeShortLE(int p0){ return null; }
public ByteBuf writeZero(int p0){ return null; }
public ByteBuf writerIndex(int p0){ return null; }
public ByteBufAllocator alloc(){ return null; }
public ByteBuffer internalNioBuffer(int p0, int p1){ return null; }
public ByteBuffer nioBuffer(){ return null; }
public ByteBuffer nioBuffer(int p0, int p1){ return null; }
public ByteBuffer[] nioBuffers(){ return null; }
public ByteBuffer[] nioBuffers(int p0, int p1){ return null; }
public ByteOrder order(){ return null; }
public CharSequence getCharSequence(int p0, int p1, Charset p2){ return null; }
public CharSequence readCharSequence(int p0, Charset p1){ return null; }
public String toString(){ return null; }
public String toString(Charset p0){ return null; }
public String toString(int p0, int p1, Charset p2){ return null; }
public SwappedByteBuf(ByteBuf p0){}
public boolean equals(Object p0){ return false; }
public boolean getBoolean(int p0){ return false; }
public boolean hasArray(){ return false; }
public boolean hasMemoryAddress(){ return false; }
public boolean isContiguous(){ return false; }
public boolean isDirect(){ return false; }
public boolean isReadOnly(){ return false; }
public boolean isReadable(){ return false; }
public boolean isReadable(int p0){ return false; }
public boolean isWritable(){ return false; }
public boolean isWritable(int p0){ return false; }
public boolean readBoolean(){ return false; }
public boolean release(){ return false; }
public boolean release(int p0){ return false; }
public byte getByte(int p0){ return 0; }
public byte readByte(){ return 0; }
public byte[] array(){ return null; }
public char getChar(int p0){ return '0'; }
public char readChar(){ return '0'; }
public double getDouble(int p0){ return 0; }
public double readDouble(){ return 0; }
public float getFloat(int p0){ return 0; }
public float readFloat(){ return 0; }
public int arrayOffset(){ return 0; }
public int bytesBefore(byte p0){ return 0; }
public int bytesBefore(int p0, byte p1){ return 0; }
public int bytesBefore(int p0, int p1, byte p2){ return 0; }
public int capacity(){ return 0; }
public int compareTo(ByteBuf p0){ return 0; }
public int ensureWritable(int p0, boolean p1){ return 0; }
public int forEachByte(ByteProcessor p0){ return 0; }
public int forEachByte(int p0, int p1, ByteProcessor p2){ return 0; }
public int forEachByteDesc(ByteProcessor p0){ return 0; }
public int forEachByteDesc(int p0, int p1, ByteProcessor p2){ return 0; }
public int getBytes(int p0, FileChannel p1, long p2, int p3){ return 0; }
public int getBytes(int p0, GatheringByteChannel p1, int p2){ return 0; }
public int getInt(int p0){ return 0; }
public int getIntLE(int p0){ return 0; }
public int getMedium(int p0){ return 0; }
public int getMediumLE(int p0){ return 0; }
public int getUnsignedMedium(int p0){ return 0; }
public int getUnsignedMediumLE(int p0){ return 0; }
public int getUnsignedShort(int p0){ return 0; }
public int getUnsignedShortLE(int p0){ return 0; }
public int hashCode(){ return 0; }
public int indexOf(int p0, int p1, byte p2){ return 0; }
public int maxCapacity(){ return 0; }
public int maxFastWritableBytes(){ return 0; }
public int maxWritableBytes(){ return 0; }
public int nioBufferCount(){ return 0; }
public int readBytes(FileChannel p0, long p1, int p2){ return 0; }
public int readBytes(GatheringByteChannel p0, int p1){ return 0; }
public int readInt(){ return 0; }
public int readIntLE(){ return 0; }
public int readMedium(){ return 0; }
public int readMediumLE(){ return 0; }
public int readUnsignedMedium(){ return 0; }
public int readUnsignedMediumLE(){ return 0; }
public int readUnsignedShort(){ return 0; }
public int readUnsignedShortLE(){ return 0; }
public int readableBytes(){ return 0; }
public int readerIndex(){ return 0; }
public int refCnt(){ return 0; }
public int setBytes(int p0, FileChannel p1, long p2, int p3){ return 0; }
public int setBytes(int p0, InputStream p1, int p2){ return 0; }
public int setBytes(int p0, ScatteringByteChannel p1, int p2){ return 0; }
public int setCharSequence(int p0, CharSequence p1, Charset p2){ return 0; }
public int writableBytes(){ return 0; }
public int writeBytes(FileChannel p0, long p1, int p2){ return 0; }
public int writeBytes(InputStream p0, int p1){ return 0; }
public int writeBytes(ScatteringByteChannel p0, int p1){ return 0; }
public int writeCharSequence(CharSequence p0, Charset p1){ return 0; }
public int writerIndex(){ return 0; }
public long getLong(int p0){ return 0; }
public long getLongLE(int p0){ return 0; }
public long getUnsignedInt(int p0){ return 0; }
public long getUnsignedIntLE(int p0){ return 0; }
public long memoryAddress(){ return 0; }
public long readLong(){ return 0; }
public long readLongLE(){ return 0; }
public long readUnsignedInt(){ return 0; }
public long readUnsignedIntLE(){ return 0; }
public short getShort(int p0){ return 0; }
public short getShortLE(int p0){ return 0; }
public short getUnsignedByte(int p0){ return 0; }
public short readShort(){ return 0; }
public short readShortLE(){ return 0; }
public short readUnsignedByte(){ return 0; }
}

66
java/ql/test/stubs/netty-4.1.x/io/netty/buffer/Unpooled.java generated Normal file
View File

@@ -0,0 +1,66 @@
// Generated automatically from io.netty.buffer.Unpooled for testing purposes
package io.netty.buffer;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.CompositeByteBuf;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
public class Unpooled
{
protected Unpooled() {}
public static ByteBuf EMPTY_BUFFER = null;
public static ByteBuf buffer(){ return null; }
public static ByteBuf buffer(int p0){ return null; }
public static ByteBuf buffer(int p0, int p1){ return null; }
public static ByteBuf copiedBuffer(ByteBuf p0){ return null; }
public static ByteBuf copiedBuffer(ByteBuf... p0){ return null; }
public static ByteBuf copiedBuffer(ByteBuffer p0){ return null; }
public static ByteBuf copiedBuffer(ByteBuffer... p0){ return null; }
public static ByteBuf copiedBuffer(CharSequence p0, Charset p1){ return null; }
public static ByteBuf copiedBuffer(CharSequence p0, int p1, int p2, Charset p3){ return null; }
public static ByteBuf copiedBuffer(byte[] p0){ return null; }
public static ByteBuf copiedBuffer(byte[] p0, int p1, int p2){ return null; }
public static ByteBuf copiedBuffer(byte[]... p0){ return null; }
public static ByteBuf copiedBuffer(char[] p0, Charset p1){ return null; }
public static ByteBuf copiedBuffer(char[] p0, int p1, int p2, Charset p3){ return null; }
public static ByteBuf copyBoolean(boolean p0){ return null; }
public static ByteBuf copyBoolean(boolean... p0){ return null; }
public static ByteBuf copyDouble(double p0){ return null; }
public static ByteBuf copyDouble(double... p0){ return null; }
public static ByteBuf copyFloat(float p0){ return null; }
public static ByteBuf copyFloat(float... p0){ return null; }
public static ByteBuf copyInt(int p0){ return null; }
public static ByteBuf copyInt(int... p0){ return null; }
public static ByteBuf copyLong(long p0){ return null; }
public static ByteBuf copyLong(long... p0){ return null; }
public static ByteBuf copyMedium(int p0){ return null; }
public static ByteBuf copyMedium(int... p0){ return null; }
public static ByteBuf copyShort(int p0){ return null; }
public static ByteBuf copyShort(int... p0){ return null; }
public static ByteBuf copyShort(short... p0){ return null; }
public static ByteBuf directBuffer(){ return null; }
public static ByteBuf directBuffer(int p0){ return null; }
public static ByteBuf directBuffer(int p0, int p1){ return null; }
public static ByteBuf unmodifiableBuffer(ByteBuf p0){ return null; }
public static ByteBuf unmodifiableBuffer(ByteBuf... p0){ return null; }
public static ByteBuf unreleasableBuffer(ByteBuf p0){ return null; }
public static ByteBuf wrappedBuffer(ByteBuf p0){ return null; }
public static ByteBuf wrappedBuffer(ByteBuf... p0){ return null; }
public static ByteBuf wrappedBuffer(ByteBuffer p0){ return null; }
public static ByteBuf wrappedBuffer(ByteBuffer... p0){ return null; }
public static ByteBuf wrappedBuffer(byte[] p0){ return null; }
public static ByteBuf wrappedBuffer(byte[] p0, int p1, int p2){ return null; }
public static ByteBuf wrappedBuffer(byte[]... p0){ return null; }
public static ByteBuf wrappedBuffer(int p0, ByteBuf... p1){ return null; }
public static ByteBuf wrappedBuffer(int p0, ByteBuffer... p1){ return null; }
public static ByteBuf wrappedBuffer(int p0, byte[]... p1){ return null; }
public static ByteBuf wrappedBuffer(long p0, int p1, boolean p2){ return null; }
public static ByteBuf wrappedUnmodifiableBuffer(ByteBuf... p0){ return null; }
public static ByteOrder BIG_ENDIAN = null;
public static ByteOrder LITTLE_ENDIAN = null;
public static CompositeByteBuf compositeBuffer(){ return null; }
public static CompositeByteBuf compositeBuffer(int p0){ return null; }
}

58
java/ql/test/stubs/netty-4.1.x/io/netty/channel/Channel.java generated Normal file
View File

@@ -0,0 +1,58 @@
// Generated automatically from io.netty.channel.Channel for testing purposes
package io.netty.channel;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelConfig;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelId;
import io.netty.channel.ChannelMetadata;
import io.netty.channel.ChannelOutboundBuffer;
import io.netty.channel.ChannelOutboundInvoker;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.ChannelPromise;
import io.netty.channel.EventLoop;
import io.netty.channel.RecvByteBufAllocator;
import io.netty.util.AttributeMap;
import java.net.SocketAddress;
public interface Channel extends AttributeMap, ChannelOutboundInvoker, Comparable<Channel>
{
ByteBufAllocator alloc();
Channel flush();
Channel parent();
Channel read();
Channel.Unsafe unsafe();
ChannelConfig config();
ChannelFuture closeFuture();
ChannelId id();
ChannelMetadata metadata();
ChannelPipeline pipeline();
EventLoop eventLoop();
SocketAddress localAddress();
SocketAddress remoteAddress();
boolean isActive();
boolean isOpen();
boolean isRegistered();
boolean isWritable();
long bytesBeforeUnwritable();
long bytesBeforeWritable();
static public interface Unsafe
{
ChannelOutboundBuffer outboundBuffer();
ChannelPromise voidPromise();
RecvByteBufAllocator.Handle recvBufAllocHandle();
SocketAddress localAddress();
SocketAddress remoteAddress();
void beginRead();
void bind(SocketAddress p0, ChannelPromise p1);
void close(ChannelPromise p0);
void closeForcibly();
void connect(SocketAddress p0, SocketAddress p1, ChannelPromise p2);
void deregister(ChannelPromise p0);
void disconnect(ChannelPromise p0);
void flush();
void register(EventLoop p0, ChannelPromise p1);
void write(Object p0, ChannelPromise p1);
}
}

40
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelConfig.java generated Normal file
View File

@@ -0,0 +1,40 @@
// Generated automatically from io.netty.channel.ChannelConfig for testing purposes
package io.netty.channel;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelOption;
import io.netty.channel.MessageSizeEstimator;
import io.netty.channel.RecvByteBufAllocator;
import io.netty.channel.WriteBufferWaterMark;
import java.util.Map;
public interface ChannelConfig
{
<T extends RecvByteBufAllocator> T getRecvByteBufAllocator();
<T> T getOption(io.netty.channel.ChannelOption<T> p0);
<T> boolean setOption(io.netty.channel.ChannelOption<T> p0, T p1);
ByteBufAllocator getAllocator();
ChannelConfig setAllocator(ByteBufAllocator p0);
ChannelConfig setAutoClose(boolean p0);
ChannelConfig setAutoRead(boolean p0);
ChannelConfig setConnectTimeoutMillis(int p0);
ChannelConfig setMaxMessagesPerRead(int p0);
ChannelConfig setMessageSizeEstimator(MessageSizeEstimator p0);
ChannelConfig setRecvByteBufAllocator(RecvByteBufAllocator p0);
ChannelConfig setWriteBufferHighWaterMark(int p0);
ChannelConfig setWriteBufferLowWaterMark(int p0);
ChannelConfig setWriteBufferWaterMark(WriteBufferWaterMark p0);
ChannelConfig setWriteSpinCount(int p0);
Map<ChannelOption<? extends Object>, Object> getOptions();
MessageSizeEstimator getMessageSizeEstimator();
WriteBufferWaterMark getWriteBufferWaterMark();
boolean isAutoClose();
boolean isAutoRead();
boolean setOptions(Map<ChannelOption<? extends Object>, ? extends Object> p0);
int getConnectTimeoutMillis();
int getMaxMessagesPerRead();
int getWriteBufferHighWaterMark();
int getWriteBufferLowWaterMark();
int getWriteSpinCount();
}

20
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelFuture.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from io.netty.channel.ChannelFuture for testing purposes
package io.netty.channel;
import io.netty.channel.Channel;
import io.netty.util.concurrent.GenericFutureListener;
public interface ChannelFuture extends io.netty.util.concurrent.Future<Void>
{
Channel channel();
ChannelFuture addListener(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>> p0);
ChannelFuture addListeners(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>>... p0);
ChannelFuture await();
ChannelFuture awaitUninterruptibly();
ChannelFuture removeListener(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>> p0);
ChannelFuture removeListeners(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>>... p0);
ChannelFuture sync();
ChannelFuture syncUninterruptibly();
boolean isVoid();
}

12
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelHandler.java generated Normal file
View File

@@ -0,0 +1,12 @@
// Generated automatically from io.netty.channel.ChannelHandler for testing purposes
package io.netty.channel;
import io.netty.channel.ChannelHandlerContext;
public interface ChannelHandler
{
void exceptionCaught(ChannelHandlerContext p0, Throwable p1);
void handlerAdded(ChannelHandlerContext p0);
void handlerRemoved(ChannelHandlerContext p0);
}

16
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelHandlerAdapter.java generated Normal file
View File

@@ -0,0 +1,16 @@
// Generated automatically from io.netty.channel.ChannelHandlerAdapter for testing purposes
package io.netty.channel;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
abstract public class ChannelHandlerAdapter implements ChannelHandler
{
protected void ensureNotSharable(){}
public ChannelHandlerAdapter(){}
public boolean isSharable(){ return false; }
public void exceptionCaught(ChannelHandlerContext p0, Throwable p1){}
public void handlerAdded(ChannelHandlerContext p0){}
public void handlerRemoved(ChannelHandlerContext p0){}
}

38
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelHandlerContext.java generated Normal file
View File

@@ -0,0 +1,38 @@
// Generated automatically from io.netty.channel.ChannelHandlerContext for testing purposes
package io.netty.channel;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelInboundInvoker;
import io.netty.channel.ChannelOutboundInvoker;
import io.netty.channel.ChannelPipeline;
import io.netty.util.Attribute;
import io.netty.util.AttributeKey;
import io.netty.util.AttributeMap;
import io.netty.util.concurrent.EventExecutor;
public interface ChannelHandlerContext extends AttributeMap, ChannelInboundInvoker, ChannelOutboundInvoker
{
<T> boolean hasAttr(io.netty.util.AttributeKey<T> p0);
<T> io.netty.util.Attribute<T> attr(io.netty.util.AttributeKey<T> p0);
ByteBufAllocator alloc();
Channel channel();
ChannelHandler handler();
ChannelHandlerContext fireChannelActive();
ChannelHandlerContext fireChannelInactive();
ChannelHandlerContext fireChannelRead(Object p0);
ChannelHandlerContext fireChannelReadComplete();
ChannelHandlerContext fireChannelRegistered();
ChannelHandlerContext fireChannelUnregistered();
ChannelHandlerContext fireChannelWritabilityChanged();
ChannelHandlerContext fireExceptionCaught(Throwable p0);
ChannelHandlerContext fireUserEventTriggered(Object p0);
ChannelHandlerContext flush();
ChannelHandlerContext read();
ChannelPipeline pipeline();
EventExecutor executor();
String name();
boolean isRemoved();
}

11
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelId.java generated Normal file
View File

@@ -0,0 +1,11 @@
// Generated automatically from io.netty.channel.ChannelId for testing purposes
package io.netty.channel;
import java.io.Serializable;
public interface ChannelId extends Comparable<ChannelId>, Serializable
{
String asLongText();
String asShortText();
}

19
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelInboundHandler.java generated Normal file
View File

@@ -0,0 +1,19 @@
// Generated automatically from io.netty.channel.ChannelInboundHandler for testing purposes
package io.netty.channel;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
public interface ChannelInboundHandler extends ChannelHandler
{
void channelActive(ChannelHandlerContext p0);
void channelInactive(ChannelHandlerContext p0);
void channelRead(ChannelHandlerContext p0, Object p1);
void channelReadComplete(ChannelHandlerContext p0);
void channelRegistered(ChannelHandlerContext p0);
void channelUnregistered(ChannelHandlerContext p0);
void channelWritabilityChanged(ChannelHandlerContext p0);
void exceptionCaught(ChannelHandlerContext p0, Throwable p1);
void userEventTriggered(ChannelHandlerContext p0, Object p1);
}

21
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelInboundHandlerAdapter.java generated Normal file
View File

@@ -0,0 +1,21 @@
// Generated automatically from io.netty.channel.ChannelInboundHandlerAdapter for testing purposes
package io.netty.channel;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandler;
public class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelInboundHandler
{
public ChannelInboundHandlerAdapter(){}
public void channelActive(ChannelHandlerContext p0){}
public void channelInactive(ChannelHandlerContext p0){}
public void channelRead(ChannelHandlerContext p0, Object p1){}
public void channelReadComplete(ChannelHandlerContext p0){}
public void channelRegistered(ChannelHandlerContext p0){}
public void channelUnregistered(ChannelHandlerContext p0){}
public void channelWritabilityChanged(ChannelHandlerContext p0){}
public void exceptionCaught(ChannelHandlerContext p0, Throwable p1){}
public void userEventTriggered(ChannelHandlerContext p0, Object p1){}
}

17
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelInboundInvoker.java generated Normal file
View File

@@ -0,0 +1,17 @@
// Generated automatically from io.netty.channel.ChannelInboundInvoker for testing purposes
package io.netty.channel;
public interface ChannelInboundInvoker
{
ChannelInboundInvoker fireChannelActive();
ChannelInboundInvoker fireChannelInactive();
ChannelInboundInvoker fireChannelRead(Object p0);
ChannelInboundInvoker fireChannelReadComplete();
ChannelInboundInvoker fireChannelRegistered();
ChannelInboundInvoker fireChannelUnregistered();
ChannelInboundInvoker fireChannelWritabilityChanged();
ChannelInboundInvoker fireExceptionCaught(Throwable p0);
ChannelInboundInvoker fireUserEventTriggered(Object p0);
}

13
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelMetadata.java generated Normal file
View File

@@ -0,0 +1,13 @@
// Generated automatically from io.netty.channel.ChannelMetadata for testing purposes
package io.netty.channel;
public class ChannelMetadata
{
protected ChannelMetadata() {}
public ChannelMetadata(boolean p0){}
public ChannelMetadata(boolean p0, int p1){}
public boolean hasDisconnect(){ return false; }
public int defaultMaxMessagesPerRead(){ return 0; }
}

53
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelOption.java generated Normal file
View File

@@ -0,0 +1,53 @@
// Generated automatically from io.netty.channel.ChannelOption for testing purposes
package io.netty.channel;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.MessageSizeEstimator;
import io.netty.channel.RecvByteBufAllocator;
import io.netty.channel.WriteBufferWaterMark;
import io.netty.util.AbstractConstant;
import java.net.InetAddress;
import java.net.NetworkInterface;
public class ChannelOption<T> extends AbstractConstant<ChannelOption<T>>
{
protected ChannelOption() {}
protected ChannelOption(String p0){}
public static <T> io.netty.channel.ChannelOption<T> newInstance(String p0){ return null; }
public static <T> io.netty.channel.ChannelOption<T> valueOf(Class<? extends Object> p0, String p1){ return null; }
public static <T> io.netty.channel.ChannelOption<T> valueOf(String p0){ return null; }
public static ChannelOption<Boolean> ALLOW_HALF_CLOSURE = null;
public static ChannelOption<Boolean> AUTO_CLOSE = null;
public static ChannelOption<Boolean> AUTO_READ = null;
public static ChannelOption<Boolean> DATAGRAM_CHANNEL_ACTIVE_ON_REGISTRATION = null;
public static ChannelOption<Boolean> IP_MULTICAST_LOOP_DISABLED = null;
public static ChannelOption<Boolean> SINGLE_EVENTEXECUTOR_PER_GROUP = null;
public static ChannelOption<Boolean> SO_BROADCAST = null;
public static ChannelOption<Boolean> SO_KEEPALIVE = null;
public static ChannelOption<Boolean> SO_REUSEADDR = null;
public static ChannelOption<Boolean> TCP_FASTOPEN_CONNECT = null;
public static ChannelOption<Boolean> TCP_NODELAY = null;
public static ChannelOption<ByteBufAllocator> ALLOCATOR = null;
public static ChannelOption<InetAddress> IP_MULTICAST_ADDR = null;
public static ChannelOption<Integer> CONNECT_TIMEOUT_MILLIS = null;
public static ChannelOption<Integer> IP_MULTICAST_TTL = null;
public static ChannelOption<Integer> IP_TOS = null;
public static ChannelOption<Integer> MAX_MESSAGES_PER_READ = null;
public static ChannelOption<Integer> MAX_MESSAGES_PER_WRITE = null;
public static ChannelOption<Integer> SO_BACKLOG = null;
public static ChannelOption<Integer> SO_LINGER = null;
public static ChannelOption<Integer> SO_RCVBUF = null;
public static ChannelOption<Integer> SO_SNDBUF = null;
public static ChannelOption<Integer> SO_TIMEOUT = null;
public static ChannelOption<Integer> TCP_FASTOPEN = null;
public static ChannelOption<Integer> WRITE_BUFFER_HIGH_WATER_MARK = null;
public static ChannelOption<Integer> WRITE_BUFFER_LOW_WATER_MARK = null;
public static ChannelOption<Integer> WRITE_SPIN_COUNT = null;
public static ChannelOption<MessageSizeEstimator> MESSAGE_SIZE_ESTIMATOR = null;
public static ChannelOption<NetworkInterface> IP_MULTICAST_IF = null;
public static ChannelOption<RecvByteBufAllocator> RCVBUF_ALLOCATOR = null;
public static ChannelOption<WriteBufferWaterMark> WRITE_BUFFER_WATER_MARK = null;
public static boolean exists(String p0){ return false; }
public void validate(T p0){}
}

37
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelOutboundBuffer.java generated Normal file
View File

@@ -0,0 +1,37 @@
// Generated automatically from io.netty.channel.ChannelOutboundBuffer for testing purposes
package io.netty.channel;
import io.netty.channel.ChannelPromise;
import java.nio.ByteBuffer;
public class ChannelOutboundBuffer
{
protected ChannelOutboundBuffer() {}
public ByteBuffer[] nioBuffers(){ return null; }
public ByteBuffer[] nioBuffers(int p0, long p1){ return null; }
public Object current(){ return null; }
public boolean getUserDefinedWritability(int p0){ return false; }
public boolean isEmpty(){ return false; }
public boolean isWritable(){ return false; }
public boolean remove(){ return false; }
public boolean remove(Throwable p0){ return false; }
public int nioBufferCount(){ return 0; }
public int size(){ return 0; }
public long bytesBeforeUnwritable(){ return 0; }
public long bytesBeforeWritable(){ return 0; }
public long currentProgress(){ return 0; }
public long nioBufferSize(){ return 0; }
public long totalPendingWriteBytes(){ return 0; }
public void addFlush(){}
public void addMessage(Object p0, int p1, ChannelPromise p2){}
public void forEachFlushedMessage(ChannelOutboundBuffer.MessageProcessor p0){}
public void progress(long p0){}
public void recycle(){}
public void removeBytes(long p0){}
public void setUserDefinedWritability(int p0, boolean p1){}
static public interface MessageProcessor
{
boolean processMessage(Object p0);
}
}

35
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelOutboundInvoker.java generated Normal file
View File

@@ -0,0 +1,35 @@
// Generated automatically from io.netty.channel.ChannelOutboundInvoker for testing purposes
package io.netty.channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelProgressivePromise;
import io.netty.channel.ChannelPromise;
import java.net.SocketAddress;
public interface ChannelOutboundInvoker
{
ChannelFuture bind(SocketAddress p0);
ChannelFuture bind(SocketAddress p0, ChannelPromise p1);
ChannelFuture close();
ChannelFuture close(ChannelPromise p0);
ChannelFuture connect(SocketAddress p0);
ChannelFuture connect(SocketAddress p0, ChannelPromise p1);
ChannelFuture connect(SocketAddress p0, SocketAddress p1);
ChannelFuture connect(SocketAddress p0, SocketAddress p1, ChannelPromise p2);
ChannelFuture deregister();
ChannelFuture deregister(ChannelPromise p0);
ChannelFuture disconnect();
ChannelFuture disconnect(ChannelPromise p0);
ChannelFuture newFailedFuture(Throwable p0);
ChannelFuture newSucceededFuture();
ChannelFuture write(Object p0);
ChannelFuture write(Object p0, ChannelPromise p1);
ChannelFuture writeAndFlush(Object p0);
ChannelFuture writeAndFlush(Object p0, ChannelPromise p1);
ChannelOutboundInvoker flush();
ChannelOutboundInvoker read();
ChannelProgressivePromise newProgressivePromise();
ChannelPromise newPromise();
ChannelPromise voidPromise();
}

58
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelPipeline.java generated Normal file
View File

@@ -0,0 +1,58 @@
// Generated automatically from io.netty.channel.ChannelPipeline for testing purposes
package io.netty.channel;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundInvoker;
import io.netty.channel.ChannelOutboundInvoker;
import io.netty.util.concurrent.EventExecutorGroup;
import java.util.List;
import java.util.Map;
public interface ChannelPipeline extends ChannelInboundInvoker, ChannelOutboundInvoker, Iterable<Map.Entry<String, ChannelHandler>>
{
<T extends ChannelHandler> T get(java.lang.Class<T> p0);
<T extends ChannelHandler> T remove(java.lang.Class<T> p0);
<T extends ChannelHandler> T replace(java.lang.Class<T> p0, String p1, ChannelHandler p2);
Channel channel();
ChannelHandler first();
ChannelHandler get(String p0);
ChannelHandler last();
ChannelHandler remove(String p0);
ChannelHandler removeFirst();
ChannelHandler removeLast();
ChannelHandler replace(String p0, String p1, ChannelHandler p2);
ChannelHandlerContext context(ChannelHandler p0);
ChannelHandlerContext context(Class<? extends ChannelHandler> p0);
ChannelHandlerContext context(String p0);
ChannelHandlerContext firstContext();
ChannelHandlerContext lastContext();
ChannelPipeline addAfter(EventExecutorGroup p0, String p1, String p2, ChannelHandler p3);
ChannelPipeline addAfter(String p0, String p1, ChannelHandler p2);
ChannelPipeline addBefore(EventExecutorGroup p0, String p1, String p2, ChannelHandler p3);
ChannelPipeline addBefore(String p0, String p1, ChannelHandler p2);
ChannelPipeline addFirst(ChannelHandler... p0);
ChannelPipeline addFirst(EventExecutorGroup p0, ChannelHandler... p1);
ChannelPipeline addFirst(EventExecutorGroup p0, String p1, ChannelHandler p2);
ChannelPipeline addFirst(String p0, ChannelHandler p1);
ChannelPipeline addLast(ChannelHandler... p0);
ChannelPipeline addLast(EventExecutorGroup p0, ChannelHandler... p1);
ChannelPipeline addLast(EventExecutorGroup p0, String p1, ChannelHandler p2);
ChannelPipeline addLast(String p0, ChannelHandler p1);
ChannelPipeline fireChannelActive();
ChannelPipeline fireChannelInactive();
ChannelPipeline fireChannelRead(Object p0);
ChannelPipeline fireChannelReadComplete();
ChannelPipeline fireChannelRegistered();
ChannelPipeline fireChannelUnregistered();
ChannelPipeline fireChannelWritabilityChanged();
ChannelPipeline fireExceptionCaught(Throwable p0);
ChannelPipeline fireUserEventTriggered(Object p0);
ChannelPipeline flush();
ChannelPipeline remove(ChannelHandler p0);
ChannelPipeline replace(ChannelHandler p0, String p1, ChannelHandler p2);
List<String> names();
Map<String, ChannelHandler> toMap();
}

19
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelProgressiveFuture.java generated Normal file
View File

@@ -0,0 +1,19 @@
// Generated automatically from io.netty.channel.ChannelProgressiveFuture for testing purposes
package io.netty.channel;
import io.netty.channel.ChannelFuture;
import io.netty.util.concurrent.GenericFutureListener;
import io.netty.util.concurrent.ProgressiveFuture;
public interface ChannelProgressiveFuture extends ChannelFuture, ProgressiveFuture<Void>
{
ChannelProgressiveFuture addListener(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>> p0);
ChannelProgressiveFuture addListeners(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>>... p0);
ChannelProgressiveFuture await();
ChannelProgressiveFuture awaitUninterruptibly();
ChannelProgressiveFuture removeListener(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>> p0);
ChannelProgressiveFuture removeListeners(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>>... p0);
ChannelProgressiveFuture sync();
ChannelProgressiveFuture syncUninterruptibly();
}

25
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelProgressivePromise.java generated Normal file
View File

@@ -0,0 +1,25 @@
// Generated automatically from io.netty.channel.ChannelProgressivePromise for testing purposes
package io.netty.channel;
import io.netty.channel.ChannelProgressiveFuture;
import io.netty.channel.ChannelPromise;
import io.netty.util.concurrent.GenericFutureListener;
import io.netty.util.concurrent.ProgressivePromise;
public interface ChannelProgressivePromise extends ChannelProgressiveFuture, ChannelPromise, ProgressivePromise<Void>
{
ChannelProgressivePromise addListener(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>> p0);
ChannelProgressivePromise addListeners(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>>... p0);
ChannelProgressivePromise await();
ChannelProgressivePromise awaitUninterruptibly();
ChannelProgressivePromise removeListener(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>> p0);
ChannelProgressivePromise removeListeners(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>>... p0);
ChannelProgressivePromise setFailure(Throwable p0);
ChannelProgressivePromise setProgress(long p0, long p1);
ChannelProgressivePromise setSuccess();
ChannelProgressivePromise setSuccess(Void p0);
ChannelProgressivePromise sync();
ChannelProgressivePromise syncUninterruptibly();
ChannelProgressivePromise unvoid();
}

26
java/ql/test/stubs/netty-4.1.x/io/netty/channel/ChannelPromise.java generated Normal file
View File

@@ -0,0 +1,26 @@
// Generated automatically from io.netty.channel.ChannelPromise for testing purposes
package io.netty.channel;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.util.concurrent.GenericFutureListener;
import io.netty.util.concurrent.Promise;
public interface ChannelPromise extends ChannelFuture, Promise<Void>
{
Channel channel();
ChannelPromise addListener(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>> p0);
ChannelPromise addListeners(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>>... p0);
ChannelPromise await();
ChannelPromise awaitUninterruptibly();
ChannelPromise removeListener(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>> p0);
ChannelPromise removeListeners(GenericFutureListener<? extends io.netty.util.concurrent.Future<? super Void>>... p0);
ChannelPromise setFailure(Throwable p0);
ChannelPromise setSuccess();
ChannelPromise setSuccess(Void p0);
ChannelPromise sync();
ChannelPromise syncUninterruptibly();
ChannelPromise unvoid();
boolean trySuccess();
}

28
java/ql/test/stubs/netty-4.1.x/io/netty/channel/DefaultFileRegion.java generated Normal file
View File

@@ -0,0 +1,28 @@
// Generated automatically from io.netty.channel.DefaultFileRegion for testing purposes
package io.netty.channel;
import io.netty.channel.FileRegion;
import io.netty.util.AbstractReferenceCounted;
import java.io.File;
import java.nio.channels.FileChannel;
import java.nio.channels.WritableByteChannel;
public class DefaultFileRegion extends AbstractReferenceCounted implements FileRegion
{
protected DefaultFileRegion() {}
protected void deallocate(){}
public DefaultFileRegion(File p0, long p1, long p2){}
public DefaultFileRegion(FileChannel p0, long p1, long p2){}
public FileRegion retain(){ return null; }
public FileRegion retain(int p0){ return null; }
public FileRegion touch(){ return null; }
public FileRegion touch(Object p0){ return null; }
public boolean isOpen(){ return false; }
public long count(){ return 0; }
public long position(){ return 0; }
public long transferTo(WritableByteChannel p0, long p1){ return 0; }
public long transfered(){ return 0; }
public long transferred(){ return 0; }
public void open(){}
}

11
java/ql/test/stubs/netty-4.1.x/io/netty/channel/EventLoop.java generated Normal file
View File

@@ -0,0 +1,11 @@
// Generated automatically from io.netty.channel.EventLoop for testing purposes
package io.netty.channel;
import io.netty.channel.EventLoopGroup;
import io.netty.util.concurrent.OrderedEventExecutor;
public interface EventLoop extends EventLoopGroup, OrderedEventExecutor
{
EventLoopGroup parent();
}

17
java/ql/test/stubs/netty-4.1.x/io/netty/channel/EventLoopGroup.java generated Normal file
View File

@@ -0,0 +1,17 @@
// Generated automatically from io.netty.channel.EventLoopGroup for testing purposes
package io.netty.channel;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelPromise;
import io.netty.channel.EventLoop;
import io.netty.util.concurrent.EventExecutorGroup;
public interface EventLoopGroup extends EventExecutorGroup
{
ChannelFuture register(Channel p0);
ChannelFuture register(Channel p0, ChannelPromise p1);
ChannelFuture register(ChannelPromise p0);
EventLoop next();
}

19
java/ql/test/stubs/netty-4.1.x/io/netty/channel/FileRegion.java generated Normal file
View File

@@ -0,0 +1,19 @@
// Generated automatically from io.netty.channel.FileRegion for testing purposes
package io.netty.channel;
import io.netty.util.ReferenceCounted;
import java.nio.channels.WritableByteChannel;
public interface FileRegion extends ReferenceCounted
{
FileRegion retain();
FileRegion retain(int p0);
FileRegion touch();
FileRegion touch(Object p0);
long count();
long position();
long transferTo(WritableByteChannel p0, long p1);
long transfered();
long transferred();
}

13
java/ql/test/stubs/netty-4.1.x/io/netty/channel/MessageSizeEstimator.java generated Normal file
View File

@@ -0,0 +1,13 @@
// Generated automatically from io.netty.channel.MessageSizeEstimator for testing purposes
package io.netty.channel;
public interface MessageSizeEstimator
{
MessageSizeEstimator.Handle newHandle();
static public interface Handle
{
int size(Object p0);
}
}

25
java/ql/test/stubs/netty-4.1.x/io/netty/channel/RecvByteBufAllocator.java generated Normal file
View File

@@ -0,0 +1,25 @@
// Generated automatically from io.netty.channel.RecvByteBufAllocator for testing purposes
package io.netty.channel;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelConfig;
public interface RecvByteBufAllocator
{
RecvByteBufAllocator.Handle newHandle();
static public interface Handle
{
ByteBuf allocate(ByteBufAllocator p0);
boolean continueReading();
int attemptedBytesRead();
int guess();
int lastBytesRead();
void attemptedBytesRead(int p0);
void incMessagesRead(int p0);
void lastBytesRead(int p0);
void readComplete();
void reset(ChannelConfig p0);
}
}

17
java/ql/test/stubs/netty-4.1.x/io/netty/channel/SimpleChannelInboundHandler.java generated Normal file
View File

@@ -0,0 +1,17 @@
// Generated automatically from io.netty.channel.SimpleChannelInboundHandler for testing purposes
package io.netty.channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
abstract public class SimpleChannelInboundHandler<I> extends ChannelInboundHandlerAdapter
{
protected SimpleChannelInboundHandler(){}
protected SimpleChannelInboundHandler(Class<? extends I> p0){}
protected SimpleChannelInboundHandler(Class<? extends I> p0, boolean p1){}
protected SimpleChannelInboundHandler(boolean p0){}
protected abstract void channelRead0(ChannelHandlerContext p0, I p1);
public boolean acceptInboundMessage(Object p0){ return false; }
public void channelRead(ChannelHandlerContext p0, Object p1){}
}

14
java/ql/test/stubs/netty-4.1.x/io/netty/channel/WriteBufferWaterMark.java generated Normal file
View File

@@ -0,0 +1,14 @@
// Generated automatically from io.netty.channel.WriteBufferWaterMark for testing purposes
package io.netty.channel;
public class WriteBufferWaterMark
{
protected WriteBufferWaterMark() {}
public String toString(){ return null; }
public WriteBufferWaterMark(int p0, int p1){}
public int high(){ return 0; }
public int low(){ return 0; }
public static WriteBufferWaterMark DEFAULT = null;
}

36
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/ByteToMessageDecoder.java generated Normal file
View File

@@ -0,0 +1,36 @@
// Generated automatically from io.netty.handler.codec.ByteToMessageDecoder for testing purposes
package io.netty.handler.codec;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import java.util.List;
abstract public class ByteToMessageDecoder extends ChannelInboundHandlerAdapter
{
protected ByteBuf internalBuffer(){ return null; }
protected ByteToMessageDecoder(){}
protected abstract void decode(ChannelHandlerContext p0, ByteBuf p1, List<Object> p2);
protected final void discardSomeReadBytes(){}
protected int actualReadableBytes(){ return 0; }
protected void callDecode(ChannelHandlerContext p0, ByteBuf p1, List<Object> p2){}
protected void decodeLast(ChannelHandlerContext p0, ByteBuf p1, List<Object> p2){}
protected void handlerRemoved0(ChannelHandlerContext p0){}
public boolean isSingleDecode(){ return false; }
public final void handlerRemoved(ChannelHandlerContext p0){}
public static ByteToMessageDecoder.Cumulator COMPOSITE_CUMULATOR = null;
public static ByteToMessageDecoder.Cumulator MERGE_CUMULATOR = null;
public void channelInactive(ChannelHandlerContext p0){}
public void channelRead(ChannelHandlerContext p0, Object p1){}
public void channelReadComplete(ChannelHandlerContext p0){}
public void setCumulator(ByteToMessageDecoder.Cumulator p0){}
public void setDiscardAfterReads(int p0){}
public void setSingleDecode(boolean p0){}
public void userEventTriggered(ChannelHandlerContext p0, Object p1){}
static public interface Cumulator
{
ByteBuf cumulate(ByteBufAllocator p0, ByteBuf p1, ByteBuf p2);
}
}

21
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/DecoderResult.java generated Normal file
View File

@@ -0,0 +1,21 @@
// Generated automatically from io.netty.handler.codec.DecoderResult for testing purposes
package io.netty.handler.codec;
import io.netty.util.Signal;
public class DecoderResult
{
protected DecoderResult() {}
protected DecoderResult(Throwable p0){}
protected static Signal SIGNAL_SUCCESS = null;
protected static Signal SIGNAL_UNFINISHED = null;
public String toString(){ return null; }
public Throwable cause(){ return null; }
public boolean isFailure(){ return false; }
public boolean isFinished(){ return false; }
public boolean isSuccess(){ return false; }
public static DecoderResult SUCCESS = null;
public static DecoderResult UNFINISHED = null;
public static DecoderResult failure(Throwable p0){ return null; }
}

11
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/DecoderResultProvider.java generated Normal file
View File

@@ -0,0 +1,11 @@
// Generated automatically from io.netty.handler.codec.DecoderResultProvider for testing purposes
package io.netty.handler.codec;
import io.netty.handler.codec.DecoderResult;
public interface DecoderResultProvider
{
DecoderResult decoderResult();
void setDecoderResult(DecoderResult p0);
}

105
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/Headers.java generated Normal file
View File

@@ -0,0 +1,105 @@
// Generated automatically from io.netty.handler.codec.Headers for testing purposes
package io.netty.handler.codec;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
public interface Headers<K, V, T extends Headers<K, V, T>> extends java.lang.Iterable<Map.Entry<K, V>>
{
Boolean getBoolean(K p0);
Boolean getBooleanAndRemove(K p0);
Byte getByte(K p0);
Byte getByteAndRemove(K p0);
Character getChar(K p0);
Character getCharAndRemove(K p0);
Double getDouble(K p0);
Double getDoubleAndRemove(K p0);
Float getFloat(K p0);
Float getFloatAndRemove(K p0);
Integer getInt(K p0);
Integer getIntAndRemove(K p0);
List<V> getAll(K p0);
List<V> getAllAndRemove(K p0);
Long getLong(K p0);
Long getLongAndRemove(K p0);
Long getTimeMillis(K p0);
Long getTimeMillisAndRemove(K p0);
Short getShort(K p0);
Short getShortAndRemove(K p0);
T add(Headers<? extends K, ? extends V, ? extends Object> p0);
T add(K p0, Iterable<? extends V> p1);
T add(K p0, V p1);
T add(K p0, V... p1);
T addBoolean(K p0, boolean p1);
T addByte(K p0, byte p1);
T addChar(K p0, char p1);
T addDouble(K p0, double p1);
T addFloat(K p0, float p1);
T addInt(K p0, int p1);
T addLong(K p0, long p1);
T addObject(K p0, Iterable<? extends Object> p1);
T addObject(K p0, Object p1);
T addObject(K p0, Object... p1);
T addShort(K p0, short p1);
T addTimeMillis(K p0, long p1);
T clear();
T set(Headers<? extends K, ? extends V, ? extends Object> p0);
T set(K p0, Iterable<? extends V> p1);
T set(K p0, V p1);
T set(K p0, V... p1);
T setAll(Headers<? extends K, ? extends V, ? extends Object> p0);
T setBoolean(K p0, boolean p1);
T setByte(K p0, byte p1);
T setChar(K p0, char p1);
T setDouble(K p0, double p1);
T setFloat(K p0, float p1);
T setInt(K p0, int p1);
T setLong(K p0, long p1);
T setObject(K p0, Iterable<? extends Object> p1);
T setObject(K p0, Object p1);
T setObject(K p0, Object... p1);
T setShort(K p0, short p1);
T setTimeMillis(K p0, long p1);
V get(K p0);
V get(K p0, V p1);
V getAndRemove(K p0);
V getAndRemove(K p0, V p1);
boolean contains(K p0);
boolean contains(K p0, V p1);
boolean containsBoolean(K p0, boolean p1);
boolean containsByte(K p0, byte p1);
boolean containsChar(K p0, char p1);
boolean containsDouble(K p0, double p1);
boolean containsFloat(K p0, float p1);
boolean containsInt(K p0, int p1);
boolean containsLong(K p0, long p1);
boolean containsObject(K p0, Object p1);
boolean containsShort(K p0, short p1);
boolean containsTimeMillis(K p0, long p1);
boolean getBoolean(K p0, boolean p1);
boolean getBooleanAndRemove(K p0, boolean p1);
boolean isEmpty();
boolean remove(K p0);
byte getByte(K p0, byte p1);
byte getByteAndRemove(K p0, byte p1);
char getChar(K p0, char p1);
char getCharAndRemove(K p0, char p1);
double getDouble(K p0, double p1);
double getDoubleAndRemove(K p0, double p1);
float getFloat(K p0, float p1);
float getFloatAndRemove(K p0, float p1);
int getInt(K p0, int p1);
int getIntAndRemove(K p0, int p1);
int size();
java.util.Iterator<Map.Entry<K, V>> iterator();
java.util.Set<K> names();
long getLong(K p0, long p1);
long getLongAndRemove(K p0, long p1);
long getTimeMillis(K p0, long p1);
long getTimeMillisAndRemove(K p0, long p1);
short getShort(K p0, short p1);
short getShortAndRemove(K p0, short p1);
}

19
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/HeadersUtils.java generated Normal file
View File

@@ -0,0 +1,19 @@
// Generated automatically from io.netty.handler.codec.HeadersUtils for testing purposes
package io.netty.handler.codec;
import io.netty.handler.codec.Headers;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class HeadersUtils
{
protected HeadersUtils() {}
public static <K, V> List<String> getAllAsString(io.netty.handler.codec.Headers<K, V, ? extends Object> p0, K p1){ return null; }
public static <K, V> String getAsString(io.netty.handler.codec.Headers<K, V, ? extends Object> p0, K p1){ return null; }
public static <K, V> String toString(Class<? extends Object> p0, java.util.Iterator<Map.Entry<K, V>> p1, int p2){ return null; }
public static Iterator<Map.Entry<String, String>> iteratorAsString(Iterable<Map.Entry<CharSequence, CharSequence>> p0){ return null; }
public static Set<String> namesAsString(Headers<CharSequence, CharSequence, ? extends Object> p0){ return null; }
}

26
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/base64/Base64.java generated Normal file
View File

@@ -0,0 +1,26 @@
// Generated automatically from io.netty.handler.codec.base64.Base64 for testing purposes
package io.netty.handler.codec.base64;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.handler.codec.base64.Base64Dialect;
public class Base64
{
protected Base64() {}
public static ByteBuf decode(ByteBuf p0){ return null; }
public static ByteBuf decode(ByteBuf p0, Base64Dialect p1){ return null; }
public static ByteBuf decode(ByteBuf p0, int p1, int p2){ return null; }
public static ByteBuf decode(ByteBuf p0, int p1, int p2, Base64Dialect p3){ return null; }
public static ByteBuf decode(ByteBuf p0, int p1, int p2, Base64Dialect p3, ByteBufAllocator p4){ return null; }
public static ByteBuf encode(ByteBuf p0){ return null; }
public static ByteBuf encode(ByteBuf p0, Base64Dialect p1){ return null; }
public static ByteBuf encode(ByteBuf p0, boolean p1){ return null; }
public static ByteBuf encode(ByteBuf p0, boolean p1, Base64Dialect p2){ return null; }
public static ByteBuf encode(ByteBuf p0, int p1, int p2){ return null; }
public static ByteBuf encode(ByteBuf p0, int p1, int p2, Base64Dialect p3){ return null; }
public static ByteBuf encode(ByteBuf p0, int p1, int p2, boolean p3){ return null; }
public static ByteBuf encode(ByteBuf p0, int p1, int p2, boolean p3, Base64Dialect p4){ return null; }
public static ByteBuf encode(ByteBuf p0, int p1, int p2, boolean p3, Base64Dialect p4, ByteBufAllocator p5){ return null; }
}

10
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/base64/Base64Dialect.java generated Normal file
View File

@@ -0,0 +1,10 @@
// Generated automatically from io.netty.handler.codec.base64.Base64Dialect for testing purposes
package io.netty.handler.codec.base64;
public enum Base64Dialect
{
ORDERED, STANDARD, URL_SAFE;
private Base64Dialect() {}
}

19
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/FullHttpMessage.java generated Normal file
View File

@@ -0,0 +1,19 @@
// Generated automatically from io.netty.handler.codec.http.FullHttpMessage for testing purposes
package io.netty.handler.codec.http;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.http.HttpMessage;
import io.netty.handler.codec.http.LastHttpContent;
public interface FullHttpMessage extends HttpMessage, LastHttpContent
{
FullHttpMessage copy();
FullHttpMessage duplicate();
FullHttpMessage replace(ByteBuf p0);
FullHttpMessage retain();
FullHttpMessage retain(int p0);
FullHttpMessage retainedDuplicate();
FullHttpMessage touch();
FullHttpMessage touch(Object p0);
}

24
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/FullHttpRequest.java generated Normal file
View File

@@ -0,0 +1,24 @@
// Generated automatically from io.netty.handler.codec.http.FullHttpRequest for testing purposes
package io.netty.handler.codec.http;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.http.FullHttpMessage;
import io.netty.handler.codec.http.HttpMethod;
import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.HttpVersion;
public interface FullHttpRequest extends FullHttpMessage, HttpRequest
{
FullHttpRequest copy();
FullHttpRequest duplicate();
FullHttpRequest replace(ByteBuf p0);
FullHttpRequest retain();
FullHttpRequest retain(int p0);
FullHttpRequest retainedDuplicate();
FullHttpRequest setMethod(HttpMethod p0);
FullHttpRequest setProtocolVersion(HttpVersion p0);
FullHttpRequest setUri(String p0);
FullHttpRequest touch();
FullHttpRequest touch(Object p0);
}

23
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/FullHttpResponse.java generated Normal file
View File

@@ -0,0 +1,23 @@
// Generated automatically from io.netty.handler.codec.http.FullHttpResponse for testing purposes
package io.netty.handler.codec.http;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.http.FullHttpMessage;
import io.netty.handler.codec.http.HttpResponse;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
public interface FullHttpResponse extends FullHttpMessage, HttpResponse
{
FullHttpResponse copy();
FullHttpResponse duplicate();
FullHttpResponse replace(ByteBuf p0);
FullHttpResponse retain();
FullHttpResponse retain(int p0);
FullHttpResponse retainedDuplicate();
FullHttpResponse setProtocolVersion(HttpVersion p0);
FullHttpResponse setStatus(HttpResponseStatus p0);
FullHttpResponse touch();
FullHttpResponse touch(Object p0);
}

19
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpContent.java generated Normal file
View File

@@ -0,0 +1,19 @@
// Generated automatically from io.netty.handler.codec.http.HttpContent for testing purposes
package io.netty.handler.codec.http;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufHolder;
import io.netty.handler.codec.http.HttpObject;
public interface HttpContent extends ByteBufHolder, HttpObject
{
HttpContent copy();
HttpContent duplicate();
HttpContent replace(ByteBuf p0);
HttpContent retain();
HttpContent retain(int p0);
HttpContent retainedDuplicate();
HttpContent touch();
HttpContent touch(Object p0);
}

119
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpHeaders.java generated Normal file
View File

@@ -0,0 +1,119 @@
// Generated automatically from io.netty.handler.codec.http.HttpHeaders for testing purposes
package io.netty.handler.codec.http;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.http.HttpMessage;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
abstract public class HttpHeaders implements Iterable<Map.Entry<String, String>>
{
protected HttpHeaders(){}
public HttpHeaders add(CharSequence p0, Iterable<? extends Object> p1){ return null; }
public HttpHeaders add(CharSequence p0, Object p1){ return null; }
public HttpHeaders add(HttpHeaders p0){ return null; }
public HttpHeaders copy(){ return null; }
public HttpHeaders remove(CharSequence p0){ return null; }
public HttpHeaders set(CharSequence p0, Iterable<? extends Object> p1){ return null; }
public HttpHeaders set(CharSequence p0, Object p1){ return null; }
public HttpHeaders set(HttpHeaders p0){ return null; }
public HttpHeaders setAll(HttpHeaders p0){ return null; }
public Iterator<? extends CharSequence> valueCharSequenceIterator(CharSequence p0){ return null; }
public Iterator<String> valueStringIterator(CharSequence p0){ return null; }
public List<String> getAll(CharSequence p0){ return null; }
public String get(CharSequence p0){ return null; }
public String get(CharSequence p0, String p1){ return null; }
public String toString(){ return null; }
public abstract HttpHeaders add(String p0, Iterable<? extends Object> p1);
public abstract HttpHeaders add(String p0, Object p1);
public abstract HttpHeaders addInt(CharSequence p0, int p1);
public abstract HttpHeaders addShort(CharSequence p0, short p1);
public abstract HttpHeaders clear();
public abstract HttpHeaders remove(String p0);
public abstract HttpHeaders set(String p0, Iterable<? extends Object> p1);
public abstract HttpHeaders set(String p0, Object p1);
public abstract HttpHeaders setInt(CharSequence p0, int p1);
public abstract HttpHeaders setShort(CharSequence p0, short p1);
public abstract Integer getInt(CharSequence p0);
public abstract Iterator<Map.Entry<CharSequence, CharSequence>> iteratorCharSequence();
public abstract Iterator<Map.Entry<String, String>> iterator();
public abstract List<Map.Entry<String, String>> entries();
public abstract List<String> getAll(String p0);
public abstract Long getTimeMillis(CharSequence p0);
public abstract Set<String> names();
public abstract Short getShort(CharSequence p0);
public abstract String get(String p0);
public abstract boolean contains(String p0);
public abstract boolean isEmpty();
public abstract int getInt(CharSequence p0, int p1);
public abstract int size();
public abstract long getTimeMillis(CharSequence p0, long p1);
public abstract short getShort(CharSequence p0, short p1);
public boolean contains(CharSequence p0){ return false; }
public boolean contains(CharSequence p0, CharSequence p1, boolean p2){ return false; }
public boolean contains(String p0, String p1, boolean p2){ return false; }
public boolean containsValue(CharSequence p0, CharSequence p1, boolean p2){ return false; }
public final Iterator<Map.Entry<String, String>> iteratorAsString(){ return null; }
public final List<String> getAllAsString(CharSequence p0){ return null; }
public final String getAsString(CharSequence p0){ return null; }
public static CharSequence newEntity(String p0){ return null; }
public static Date getDate(HttpMessage p0){ return null; }
public static Date getDate(HttpMessage p0, Date p1){ return null; }
public static Date getDateHeader(HttpMessage p0, CharSequence p1){ return null; }
public static Date getDateHeader(HttpMessage p0, CharSequence p1, Date p2){ return null; }
public static Date getDateHeader(HttpMessage p0, String p1){ return null; }
public static Date getDateHeader(HttpMessage p0, String p1, Date p2){ return null; }
public static HttpHeaders EMPTY_HEADERS = null;
public static String getHeader(HttpMessage p0, CharSequence p1){ return null; }
public static String getHeader(HttpMessage p0, CharSequence p1, String p2){ return null; }
public static String getHeader(HttpMessage p0, String p1){ return null; }
public static String getHeader(HttpMessage p0, String p1, String p2){ return null; }
public static String getHost(HttpMessage p0){ return null; }
public static String getHost(HttpMessage p0, String p1){ return null; }
public static boolean equalsIgnoreCase(CharSequence p0, CharSequence p1){ return false; }
public static boolean is100ContinueExpected(HttpMessage p0){ return false; }
public static boolean isContentLengthSet(HttpMessage p0){ return false; }
public static boolean isKeepAlive(HttpMessage p0){ return false; }
public static boolean isTransferEncodingChunked(HttpMessage p0){ return false; }
public static int getIntHeader(HttpMessage p0, CharSequence p1){ return 0; }
public static int getIntHeader(HttpMessage p0, CharSequence p1, int p2){ return 0; }
public static int getIntHeader(HttpMessage p0, String p1){ return 0; }
public static int getIntHeader(HttpMessage p0, String p1, int p2){ return 0; }
public static long getContentLength(HttpMessage p0){ return 0; }
public static long getContentLength(HttpMessage p0, long p1){ return 0; }
public static void addDateHeader(HttpMessage p0, CharSequence p1, Date p2){}
public static void addDateHeader(HttpMessage p0, String p1, Date p2){}
public static void addHeader(HttpMessage p0, CharSequence p1, Object p2){}
public static void addHeader(HttpMessage p0, String p1, Object p2){}
public static void addIntHeader(HttpMessage p0, CharSequence p1, int p2){}
public static void addIntHeader(HttpMessage p0, String p1, int p2){}
public static void clearHeaders(HttpMessage p0){}
public static void encodeAscii(CharSequence p0, ByteBuf p1){}
public static void removeHeader(HttpMessage p0, CharSequence p1){}
public static void removeHeader(HttpMessage p0, String p1){}
public static void removeTransferEncodingChunked(HttpMessage p0){}
public static void set100ContinueExpected(HttpMessage p0){}
public static void set100ContinueExpected(HttpMessage p0, boolean p1){}
public static void setContentLength(HttpMessage p0, long p1){}
public static void setDate(HttpMessage p0, Date p1){}
public static void setDateHeader(HttpMessage p0, CharSequence p1, Date p2){}
public static void setDateHeader(HttpMessage p0, CharSequence p1, Iterable<Date> p2){}
public static void setDateHeader(HttpMessage p0, String p1, Date p2){}
public static void setDateHeader(HttpMessage p0, String p1, Iterable<Date> p2){}
public static void setHeader(HttpMessage p0, CharSequence p1, Iterable<? extends Object> p2){}
public static void setHeader(HttpMessage p0, CharSequence p1, Object p2){}
public static void setHeader(HttpMessage p0, String p1, Iterable<? extends Object> p2){}
public static void setHeader(HttpMessage p0, String p1, Object p2){}
public static void setHost(HttpMessage p0, CharSequence p1){}
public static void setHost(HttpMessage p0, String p1){}
public static void setIntHeader(HttpMessage p0, CharSequence p1, Iterable<Integer> p2){}
public static void setIntHeader(HttpMessage p0, CharSequence p1, int p2){}
public static void setIntHeader(HttpMessage p0, String p1, Iterable<Integer> p2){}
public static void setIntHeader(HttpMessage p0, String p1, int p2){}
public static void setKeepAlive(HttpMessage p0, boolean p1){}
public static void setTransferEncodingChunked(HttpMessage p0){}
}

15
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpMessage.java generated Normal file
View File

@@ -0,0 +1,15 @@
// Generated automatically from io.netty.handler.codec.http.HttpMessage for testing purposes
package io.netty.handler.codec.http;
import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.codec.http.HttpObject;
import io.netty.handler.codec.http.HttpVersion;
public interface HttpMessage extends HttpObject
{
HttpHeaders headers();
HttpMessage setProtocolVersion(HttpVersion p0);
HttpVersion getProtocolVersion();
HttpVersion protocolVersion();
}

27
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpMethod.java generated Normal file
View File

@@ -0,0 +1,27 @@
// Generated automatically from io.netty.handler.codec.http.HttpMethod for testing purposes
package io.netty.handler.codec.http;
import io.netty.util.AsciiString;
public class HttpMethod implements Comparable<HttpMethod>
{
protected HttpMethod() {}
public AsciiString asciiName(){ return null; }
public HttpMethod(String p0){}
public String name(){ return null; }
public String toString(){ return null; }
public boolean equals(Object p0){ return false; }
public int compareTo(HttpMethod p0){ return 0; }
public int hashCode(){ return 0; }
public static HttpMethod CONNECT = null;
public static HttpMethod DELETE = null;
public static HttpMethod GET = null;
public static HttpMethod HEAD = null;
public static HttpMethod OPTIONS = null;
public static HttpMethod PATCH = null;
public static HttpMethod POST = null;
public static HttpMethod PUT = null;
public static HttpMethod TRACE = null;
public static HttpMethod valueOf(String p0){ return null; }
}

11
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpObject.java generated Normal file
View File

@@ -0,0 +1,11 @@
// Generated automatically from io.netty.handler.codec.http.HttpObject for testing purposes
package io.netty.handler.codec.http;
import io.netty.handler.codec.DecoderResult;
import io.netty.handler.codec.DecoderResultProvider;
public interface HttpObject extends DecoderResultProvider
{
DecoderResult getDecoderResult();
}

18
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpRequest.java generated Normal file
View File

@@ -0,0 +1,18 @@
// Generated automatically from io.netty.handler.codec.http.HttpRequest for testing purposes
package io.netty.handler.codec.http;
import io.netty.handler.codec.http.HttpMessage;
import io.netty.handler.codec.http.HttpMethod;
import io.netty.handler.codec.http.HttpVersion;
public interface HttpRequest extends HttpMessage
{
HttpMethod getMethod();
HttpMethod method();
HttpRequest setMethod(HttpMethod p0);
HttpRequest setProtocolVersion(HttpVersion p0);
HttpRequest setUri(String p0);
String getUri();
String uri();
}

15
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpResponse.java generated Normal file
View File

@@ -0,0 +1,15 @@
// Generated automatically from io.netty.handler.codec.http.HttpResponse for testing purposes
package io.netty.handler.codec.http;
import io.netty.handler.codec.http.HttpMessage;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
public interface HttpResponse extends HttpMessage
{
HttpResponse setProtocolVersion(HttpVersion p0);
HttpResponse setStatus(HttpResponseStatus p0);
HttpResponseStatus getStatus();
HttpResponseStatus status();
}

82
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpResponseStatus.java generated Normal file
View File

@@ -0,0 +1,82 @@
// Generated automatically from io.netty.handler.codec.http.HttpResponseStatus for testing purposes
package io.netty.handler.codec.http;
import io.netty.handler.codec.http.HttpStatusClass;
import io.netty.util.AsciiString;
public class HttpResponseStatus implements Comparable<HttpResponseStatus>
{
protected HttpResponseStatus() {}
public AsciiString codeAsText(){ return null; }
public HttpResponseStatus(int p0, String p1){}
public HttpStatusClass codeClass(){ return null; }
public String reasonPhrase(){ return null; }
public String toString(){ return null; }
public boolean equals(Object p0){ return false; }
public int code(){ return 0; }
public int compareTo(HttpResponseStatus p0){ return 0; }
public int hashCode(){ return 0; }
public static HttpResponseStatus ACCEPTED = null;
public static HttpResponseStatus BAD_GATEWAY = null;
public static HttpResponseStatus BAD_REQUEST = null;
public static HttpResponseStatus CONFLICT = null;
public static HttpResponseStatus CONTINUE = null;
public static HttpResponseStatus CREATED = null;
public static HttpResponseStatus EARLY_HINTS = null;
public static HttpResponseStatus EXPECTATION_FAILED = null;
public static HttpResponseStatus FAILED_DEPENDENCY = null;
public static HttpResponseStatus FORBIDDEN = null;
public static HttpResponseStatus FOUND = null;
public static HttpResponseStatus GATEWAY_TIMEOUT = null;
public static HttpResponseStatus GONE = null;
public static HttpResponseStatus HTTP_VERSION_NOT_SUPPORTED = null;
public static HttpResponseStatus INSUFFICIENT_STORAGE = null;
public static HttpResponseStatus INTERNAL_SERVER_ERROR = null;
public static HttpResponseStatus LENGTH_REQUIRED = null;
public static HttpResponseStatus LOCKED = null;
public static HttpResponseStatus METHOD_NOT_ALLOWED = null;
public static HttpResponseStatus MISDIRECTED_REQUEST = null;
public static HttpResponseStatus MOVED_PERMANENTLY = null;
public static HttpResponseStatus MULTIPLE_CHOICES = null;
public static HttpResponseStatus MULTI_STATUS = null;
public static HttpResponseStatus NETWORK_AUTHENTICATION_REQUIRED = null;
public static HttpResponseStatus NON_AUTHORITATIVE_INFORMATION = null;
public static HttpResponseStatus NOT_ACCEPTABLE = null;
public static HttpResponseStatus NOT_EXTENDED = null;
public static HttpResponseStatus NOT_FOUND = null;
public static HttpResponseStatus NOT_IMPLEMENTED = null;
public static HttpResponseStatus NOT_MODIFIED = null;
public static HttpResponseStatus NO_CONTENT = null;
public static HttpResponseStatus OK = null;
public static HttpResponseStatus PARTIAL_CONTENT = null;
public static HttpResponseStatus PAYMENT_REQUIRED = null;
public static HttpResponseStatus PERMANENT_REDIRECT = null;
public static HttpResponseStatus PRECONDITION_FAILED = null;
public static HttpResponseStatus PRECONDITION_REQUIRED = null;
public static HttpResponseStatus PROCESSING = null;
public static HttpResponseStatus PROXY_AUTHENTICATION_REQUIRED = null;
public static HttpResponseStatus REQUESTED_RANGE_NOT_SATISFIABLE = null;
public static HttpResponseStatus REQUEST_ENTITY_TOO_LARGE = null;
public static HttpResponseStatus REQUEST_HEADER_FIELDS_TOO_LARGE = null;
public static HttpResponseStatus REQUEST_TIMEOUT = null;
public static HttpResponseStatus REQUEST_URI_TOO_LONG = null;
public static HttpResponseStatus RESET_CONTENT = null;
public static HttpResponseStatus SEE_OTHER = null;
public static HttpResponseStatus SERVICE_UNAVAILABLE = null;
public static HttpResponseStatus SWITCHING_PROTOCOLS = null;
public static HttpResponseStatus TEMPORARY_REDIRECT = null;
public static HttpResponseStatus TOO_MANY_REQUESTS = null;
public static HttpResponseStatus UNAUTHORIZED = null;
public static HttpResponseStatus UNORDERED_COLLECTION = null;
public static HttpResponseStatus UNPROCESSABLE_ENTITY = null;
public static HttpResponseStatus UNSUPPORTED_MEDIA_TYPE = null;
public static HttpResponseStatus UPGRADE_REQUIRED = null;
public static HttpResponseStatus USE_PROXY = null;
public static HttpResponseStatus VARIANT_ALSO_NEGOTIATES = null;
public static HttpResponseStatus parseLine(AsciiString p0){ return null; }
public static HttpResponseStatus parseLine(CharSequence p0){ return null; }
public static HttpResponseStatus parseLine(String p0){ return null; }
public static HttpResponseStatus valueOf(int p0){ return null; }
public static HttpResponseStatus valueOf(int p0, String p1){ return null; }
}

11
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpStatusClass.java generated Normal file
View File

@@ -0,0 +1,11 @@
// Generated automatically from io.netty.handler.codec.http.HttpStatusClass for testing purposes
package io.netty.handler.codec.http;
public enum HttpStatusClass
{
CLIENT_ERROR, INFORMATIONAL, REDIRECTION, SERVER_ERROR, SUCCESS, UNKNOWN;
private HttpStatusClass() {}
public boolean contains(int p0){ return false; }
}

23
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpVersion.java generated Normal file
View File

@@ -0,0 +1,23 @@
// Generated automatically from io.netty.handler.codec.http.HttpVersion for testing purposes
package io.netty.handler.codec.http;
public class HttpVersion implements Comparable<HttpVersion>
{
protected HttpVersion() {}
public HttpVersion(String p0, boolean p1){}
public HttpVersion(String p0, int p1, int p2, boolean p3){}
public String protocolName(){ return null; }
public String text(){ return null; }
public String toString(){ return null; }
public boolean equals(Object p0){ return false; }
public boolean isKeepAliveDefault(){ return false; }
public int compareTo(HttpVersion p0){ return 0; }
public int hashCode(){ return 0; }
public int majorVersion(){ return 0; }
public int minorVersion(){ return 0; }
public static HttpVersion HTTP_1_0 = null;
public static HttpVersion HTTP_1_1 = null;
public static HttpVersion valueOf(String p0){ return null; }
}

21
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/LastHttpContent.java generated Normal file
View File

@@ -0,0 +1,21 @@
// Generated automatically from io.netty.handler.codec.http.LastHttpContent for testing purposes
package io.netty.handler.codec.http;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.http.HttpContent;
import io.netty.handler.codec.http.HttpHeaders;
public interface LastHttpContent extends HttpContent
{
HttpHeaders trailingHeaders();
LastHttpContent copy();
LastHttpContent duplicate();
LastHttpContent replace(ByteBuf p0);
LastHttpContent retain();
LastHttpContent retain(int p0);
LastHttpContent retainedDuplicate();
LastHttpContent touch();
LastHttpContent touch(Object p0);
static LastHttpContent EMPTY_LAST_CONTENT = null;
}

31
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/QueryStringDecoder.java generated Normal file
View File

@@ -0,0 +1,31 @@
// Generated automatically from io.netty.handler.codec.http.QueryStringDecoder for testing purposes
package io.netty.handler.codec.http;
import java.net.URI;
import java.nio.charset.Charset;
import java.util.List;
import java.util.Map;
public class QueryStringDecoder
{
protected QueryStringDecoder() {}
public Map<String, List<String>> parameters(){ return null; }
public QueryStringDecoder(String p0){}
public QueryStringDecoder(String p0, Charset p1){}
public QueryStringDecoder(String p0, Charset p1, boolean p2){}
public QueryStringDecoder(String p0, Charset p1, boolean p2, int p3){}
public QueryStringDecoder(String p0, Charset p1, boolean p2, int p3, boolean p4){}
public QueryStringDecoder(String p0, boolean p1){}
public QueryStringDecoder(URI p0){}
public QueryStringDecoder(URI p0, Charset p1){}
public QueryStringDecoder(URI p0, Charset p1, int p2){}
public QueryStringDecoder(URI p0, Charset p1, int p2, boolean p3){}
public String path(){ return null; }
public String rawPath(){ return null; }
public String rawQuery(){ return null; }
public String toString(){ return null; }
public String uri(){ return null; }
public static String decodeComponent(String p0){ return null; }
public static String decodeComponent(String p0, Charset p1){ return null; }
}

158
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/cookie/Cookie.java generated
View File

@@ -1,146 +1,24 @@
/*
* Copyright 2015 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
// Generated automatically from io.netty.handler.codec.http.cookie.Cookie for testing purposes
package io.netty.handler.codec.http.cookie;
/**
* An interface defining an
* <a href="https://en.wikipedia.org/wiki/HTTP_cookie">HTTP cookie</a>.
*/
public interface Cookie extends Comparable<Cookie> {
/**
* Constant for undefined MaxAge attribute value.
*/
long UNDEFINED_MAX_AGE = Long.MIN_VALUE;
/**
* Returns the name of this {@link Cookie}.
*
* @return The name of this {@link Cookie}
*/
String name();
/**
* Returns the value of this {@link Cookie}.
*
* @return The value of this {@link Cookie}
*/
String value();
/**
* Sets the value of this {@link Cookie}.
*
* @param value The value to set
*/
void setValue(String value);
/**
* Returns true if the raw value of this {@link Cookie},
* was wrapped with double quotes in original Set-Cookie header.
*
* @return If the value of this {@link Cookie} is to be wrapped
*/
boolean wrap();
/**
* Sets true if the value of this {@link Cookie}
* is to be wrapped with double quotes.
*
* @param wrap true if wrap
*/
void setWrap(boolean wrap);
/**
* Returns the domain of this {@link Cookie}.
*
* @return The domain of this {@link Cookie}
*/
public interface Cookie extends Comparable<Cookie>
{
String domain();
/**
* Sets the domain of this {@link Cookie}.
*
* @param domain The domain to use
*/
void setDomain(String domain);
/**
* Returns the path of this {@link Cookie}.
*
* @return The {@link Cookie}'s path
*/
String name();
String path();
/**
* Sets the path of this {@link Cookie}.
*
* @param path The path to use for this {@link Cookie}
*/
void setPath(String path);
/**
* Returns the maximum age of this {@link Cookie} in seconds or {@link Cookie#UNDEFINED_MAX_AGE} if unspecified
*
* @return The maximum age of this {@link Cookie}
*/
long maxAge();
/**
* Sets the maximum age of this {@link Cookie} in seconds.
* If an age of {@code 0} is specified, this {@link Cookie} will be
* automatically removed by browser because it will expire immediately.
* If {@link Cookie#UNDEFINED_MAX_AGE} is specified, this {@link Cookie} will be removed when the
* browser is closed.
*
* @param maxAge The maximum age of this {@link Cookie} in seconds
*/
void setMaxAge(long maxAge);
/**
* Checks to see if this {@link Cookie} is secure
*
* @return True if this {@link Cookie} is secure, otherwise false
*/
boolean isSecure();
/**
* Sets the security getStatus of this {@link Cookie}
*
* @param secure True if this {@link Cookie} is to be secure, otherwise false
*/
void setSecure(boolean secure);
/**
* Checks to see if this {@link Cookie} can only be accessed via HTTP.
* If this returns true, the {@link Cookie} cannot be accessed through
* client side script - But only if the browser supports it.
* For more information, please look <a href="https://owasp.org/www-community/HttpOnly">here</a>
*
* @return True if this {@link Cookie} is HTTP-only or false if it isn't
*/
String value();
boolean isHttpOnly();
/**
* Determines if this {@link Cookie} is HTTP only.
* If set to true, this {@link Cookie} cannot be accessed by a client
* side script. However, this works only if the browser supports it.
* For for information, please look
* <a href="https://owasp.org/www-community/HttpOnly">here</a>.
*
* @param httpOnly True if the {@link Cookie} is HTTP only, otherwise false.
*/
void setHttpOnly(boolean httpOnly);
}
boolean isSecure();
boolean wrap();
long maxAge();
static long UNDEFINED_MAX_AGE = 0;
void setDomain(String p0);
void setHttpOnly(boolean p0);
void setMaxAge(long p0);
void setPath(String p0);
void setSecure(boolean p0);
void setValue(String p0);
void setWrap(boolean p0);
}

12
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/cookie/CookieDecoder.java generated Normal file
View File

@@ -0,0 +1,12 @@
// Generated automatically from io.netty.handler.codec.http.cookie.CookieDecoder for testing purposes
package io.netty.handler.codec.http.cookie;
import io.netty.handler.codec.http.cookie.DefaultCookie;
abstract public class CookieDecoder
{
protected CookieDecoder() {}
protected CookieDecoder(boolean p0){}
protected DefaultCookie initCookie(String p0, int p1, int p2, int p3, int p4){ return null; }
}

12
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/cookie/CookieEncoder.java generated Normal file
View File

@@ -0,0 +1,12 @@
// Generated automatically from io.netty.handler.codec.http.cookie.CookieEncoder for testing purposes
package io.netty.handler.codec.http.cookie;
abstract public class CookieEncoder
{
protected CookieEncoder() {}
protected CookieEncoder(boolean p0){}
protected final boolean strict = false;
protected void validateCookie(String p0, String p1){}
}

21
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/cookie/CookieHeaderNames.java generated Normal file
View File

@@ -0,0 +1,21 @@
// Generated automatically from io.netty.handler.codec.http.cookie.CookieHeaderNames for testing purposes
package io.netty.handler.codec.http.cookie;
public class CookieHeaderNames
{
protected CookieHeaderNames() {}
public static String DOMAIN = null;
public static String EXPIRES = null;
public static String HTTPONLY = null;
public static String MAX_AGE = null;
public static String PATH = null;
public static String SAMESITE = null;
public static String SECURE = null;
static public enum SameSite
{
Lax, None, Strict;
private SameSite() {}
}
}

34
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/cookie/DefaultCookie.java generated Normal file
View File

@@ -0,0 +1,34 @@
// Generated automatically from io.netty.handler.codec.http.cookie.DefaultCookie for testing purposes
package io.netty.handler.codec.http.cookie;
import io.netty.handler.codec.http.cookie.Cookie;
import io.netty.handler.codec.http.cookie.CookieHeaderNames;
public class DefaultCookie implements Cookie
{
protected DefaultCookie() {}
protected String validateValue(String p0, String p1){ return null; }
public CookieHeaderNames.SameSite sameSite(){ return null; }
public DefaultCookie(String p0, String p1){}
public String domain(){ return null; }
public String name(){ return null; }
public String path(){ return null; }
public String toString(){ return null; }
public String value(){ return null; }
public boolean equals(Object p0){ return false; }
public boolean isHttpOnly(){ return false; }
public boolean isSecure(){ return false; }
public boolean wrap(){ return false; }
public int compareTo(Cookie p0){ return 0; }
public int hashCode(){ return 0; }
public long maxAge(){ return 0; }
public void setDomain(String p0){}
public void setHttpOnly(boolean p0){}
public void setMaxAge(long p0){}
public void setPath(String p0){}
public void setSameSite(CookieHeaderNames.SameSite p0){}
public void setSecure(boolean p0){}
public void setValue(String p0){}
public void setWrap(boolean p0){}
}

17
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/cookie/ServerCookieDecoder.java generated Normal file
View File

@@ -0,0 +1,17 @@
// Generated automatically from io.netty.handler.codec.http.cookie.ServerCookieDecoder for testing purposes
package io.netty.handler.codec.http.cookie;
import io.netty.handler.codec.http.cookie.Cookie;
import io.netty.handler.codec.http.cookie.CookieDecoder;
import java.util.List;
import java.util.Set;
public class ServerCookieDecoder extends CookieDecoder
{
protected ServerCookieDecoder() {}
public List<Cookie> decodeAll(String p0){ return null; }
public Set<Cookie> decode(String p0){ return null; }
public static ServerCookieDecoder LAX = null;
public static ServerCookieDecoder STRICT = null;
}

20
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/cookie/ServerCookieEncoder.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from io.netty.handler.codec.http.cookie.ServerCookieEncoder for testing purposes
package io.netty.handler.codec.http.cookie;
import io.netty.handler.codec.http.cookie.Cookie;
import io.netty.handler.codec.http.cookie.CookieEncoder;
import java.util.Collection;
import java.util.List;
public class ServerCookieEncoder extends CookieEncoder
{
protected ServerCookieEncoder() {}
public List<String> encode(Collection<? extends Cookie> p0){ return null; }
public List<String> encode(Cookie... p0){ return null; }
public List<String> encode(Iterable<? extends Cookie> p0){ return null; }
public String encode(Cookie p0){ return null; }
public String encode(String p0, String p1){ return null; }
public static ServerCookieEncoder LAX = null;
public static ServerCookieEncoder STRICT = null;
}

20
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/multipart/Attribute.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from io.netty.handler.codec.http.multipart.Attribute for testing purposes
package io.netty.handler.codec.http.multipart;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.http.multipart.HttpData;
public interface Attribute extends HttpData
{
Attribute copy();
Attribute duplicate();
Attribute replace(ByteBuf p0);
Attribute retain();
Attribute retain(int p0);
Attribute retainedDuplicate();
Attribute touch();
Attribute touch(Object p0);
String getValue();
void setValue(String p0);
}

24
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/multipart/FileUpload.java generated Normal file
View File

@@ -0,0 +1,24 @@
// Generated automatically from io.netty.handler.codec.http.multipart.FileUpload for testing purposes
package io.netty.handler.codec.http.multipart;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.http.multipart.HttpData;
public interface FileUpload extends HttpData
{
FileUpload copy();
FileUpload duplicate();
FileUpload replace(ByteBuf p0);
FileUpload retain();
FileUpload retain(int p0);
FileUpload retainedDuplicate();
FileUpload touch();
FileUpload touch(Object p0);
String getContentTransferEncoding();
String getContentType();
String getFilename();
void setContentTransferEncoding(String p0);
void setContentType(String p0);
void setFilename(String p0);
}

43
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/multipart/HttpData.java generated Normal file
View File

@@ -0,0 +1,43 @@
// Generated automatically from io.netty.handler.codec.http.multipart.HttpData for testing purposes
package io.netty.handler.codec.http.multipart;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufHolder;
import io.netty.handler.codec.http.multipart.InterfaceHttpData;
import java.io.File;
import java.io.InputStream;
import java.nio.charset.Charset;
public interface HttpData extends ByteBufHolder, InterfaceHttpData
{
ByteBuf getByteBuf();
ByteBuf getChunk(int p0);
Charset getCharset();
File getFile();
HttpData copy();
HttpData duplicate();
HttpData replace(ByteBuf p0);
HttpData retain();
HttpData retain(int p0);
HttpData retainedDuplicate();
HttpData touch();
HttpData touch(Object p0);
String getString();
String getString(Charset p0);
boolean isCompleted();
boolean isInMemory();
boolean renameTo(File p0);
byte[] get();
long definedLength();
long getMaxSize();
long length();
void addContent(ByteBuf p0, boolean p1);
void checkSize(long p0);
void delete();
void setCharset(Charset p0);
void setContent(ByteBuf p0);
void setContent(File p0);
void setContent(InputStream p0);
void setMaxSize(long p0);
}

23
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/multipart/HttpDataFactory.java generated Normal file
View File

@@ -0,0 +1,23 @@
// Generated automatically from io.netty.handler.codec.http.multipart.HttpDataFactory for testing purposes
package io.netty.handler.codec.http.multipart;
import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.multipart.Attribute;
import io.netty.handler.codec.http.multipart.FileUpload;
import io.netty.handler.codec.http.multipart.InterfaceHttpData;
import java.nio.charset.Charset;
public interface HttpDataFactory
{
Attribute createAttribute(HttpRequest p0, String p1);
Attribute createAttribute(HttpRequest p0, String p1, String p2);
Attribute createAttribute(HttpRequest p0, String p1, long p2);
FileUpload createFileUpload(HttpRequest p0, String p1, String p2, String p3, String p4, Charset p5, long p6);
void cleanAllHttpData();
void cleanAllHttpDatas();
void cleanRequestHttpData(HttpRequest p0);
void cleanRequestHttpDatas(HttpRequest p0);
void removeHttpDataFromClean(HttpRequest p0, InterfaceHttpData p1);
void setMaxLimit(long p0);
}

34
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/multipart/HttpPostMultipartRequestDecoder.java generated Normal file
View File

@@ -0,0 +1,34 @@
// Generated automatically from io.netty.handler.codec.http.multipart.HttpPostMultipartRequestDecoder for testing purposes
package io.netty.handler.codec.http.multipart;
import io.netty.handler.codec.http.HttpContent;
import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.multipart.HttpDataFactory;
import io.netty.handler.codec.http.multipart.InterfaceHttpData;
import io.netty.handler.codec.http.multipart.InterfaceHttpPostRequestDecoder;
import java.nio.charset.Charset;
import java.util.List;
public class HttpPostMultipartRequestDecoder implements InterfaceHttpPostRequestDecoder
{
protected HttpPostMultipartRequestDecoder() {}
protected InterfaceHttpData getFileUpload(String p0){ return null; }
protected void addHttpData(InterfaceHttpData p0){}
public HttpPostMultipartRequestDecoder offer(HttpContent p0){ return null; }
public HttpPostMultipartRequestDecoder(HttpDataFactory p0, HttpRequest p1){}
public HttpPostMultipartRequestDecoder(HttpDataFactory p0, HttpRequest p1, Charset p2){}
public HttpPostMultipartRequestDecoder(HttpRequest p0){}
public InterfaceHttpData currentPartialHttpData(){ return null; }
public InterfaceHttpData getBodyHttpData(String p0){ return null; }
public InterfaceHttpData next(){ return null; }
public List<InterfaceHttpData> getBodyHttpDatas(){ return null; }
public List<InterfaceHttpData> getBodyHttpDatas(String p0){ return null; }
public boolean hasNext(){ return false; }
public boolean isMultipart(){ return false; }
public int getDiscardThreshold(){ return 0; }
public void cleanFiles(){}
public void destroy(){}
public void removeHttpDataFromClean(InterfaceHttpData p0){}
public void setDiscardThreshold(int p0){}
}

34
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/multipart/HttpPostRequestDecoder.java generated Normal file
View File

@@ -0,0 +1,34 @@
// Generated automatically from io.netty.handler.codec.http.multipart.HttpPostRequestDecoder for testing purposes
package io.netty.handler.codec.http.multipart;
import io.netty.handler.codec.http.HttpContent;
import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.multipart.HttpDataFactory;
import io.netty.handler.codec.http.multipart.InterfaceHttpData;
import io.netty.handler.codec.http.multipart.InterfaceHttpPostRequestDecoder;
import java.nio.charset.Charset;
import java.util.List;
public class HttpPostRequestDecoder implements InterfaceHttpPostRequestDecoder
{
protected HttpPostRequestDecoder() {}
protected static String[] getMultipartDataBoundary(String p0){ return null; }
public HttpPostRequestDecoder(HttpDataFactory p0, HttpRequest p1){}
public HttpPostRequestDecoder(HttpDataFactory p0, HttpRequest p1, Charset p2){}
public HttpPostRequestDecoder(HttpRequest p0){}
public InterfaceHttpData currentPartialHttpData(){ return null; }
public InterfaceHttpData getBodyHttpData(String p0){ return null; }
public InterfaceHttpData next(){ return null; }
public InterfaceHttpPostRequestDecoder offer(HttpContent p0){ return null; }
public List<InterfaceHttpData> getBodyHttpDatas(){ return null; }
public List<InterfaceHttpData> getBodyHttpDatas(String p0){ return null; }
public boolean hasNext(){ return false; }
public boolean isMultipart(){ return false; }
public int getDiscardThreshold(){ return 0; }
public static boolean isMultipart(HttpRequest p0){ return false; }
public void cleanFiles(){}
public void destroy(){}
public void removeHttpDataFromClean(InterfaceHttpData p0){}
public void setDiscardThreshold(int p0){}
}

33
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/multipart/HttpPostStandardRequestDecoder.java generated Normal file
View File

@@ -0,0 +1,33 @@
// Generated automatically from io.netty.handler.codec.http.multipart.HttpPostStandardRequestDecoder for testing purposes
package io.netty.handler.codec.http.multipart;
import io.netty.handler.codec.http.HttpContent;
import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.multipart.HttpDataFactory;
import io.netty.handler.codec.http.multipart.InterfaceHttpData;
import io.netty.handler.codec.http.multipart.InterfaceHttpPostRequestDecoder;
import java.nio.charset.Charset;
import java.util.List;
public class HttpPostStandardRequestDecoder implements InterfaceHttpPostRequestDecoder
{
protected HttpPostStandardRequestDecoder() {}
protected void addHttpData(InterfaceHttpData p0){}
public HttpPostStandardRequestDecoder offer(HttpContent p0){ return null; }
public HttpPostStandardRequestDecoder(HttpDataFactory p0, HttpRequest p1){}
public HttpPostStandardRequestDecoder(HttpDataFactory p0, HttpRequest p1, Charset p2){}
public HttpPostStandardRequestDecoder(HttpRequest p0){}
public InterfaceHttpData currentPartialHttpData(){ return null; }
public InterfaceHttpData getBodyHttpData(String p0){ return null; }
public InterfaceHttpData next(){ return null; }
public List<InterfaceHttpData> getBodyHttpDatas(){ return null; }
public List<InterfaceHttpData> getBodyHttpDatas(String p0){ return null; }
public boolean hasNext(){ return false; }
public boolean isMultipart(){ return false; }
public int getDiscardThreshold(){ return 0; }
public void cleanFiles(){}
public void destroy(){}
public void removeHttpDataFromClean(InterfaceHttpData p0){}
public void setDiscardThreshold(int p0){}
}

20
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/multipart/InterfaceHttpData.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from io.netty.handler.codec.http.multipart.InterfaceHttpData for testing purposes
package io.netty.handler.codec.http.multipart;
import io.netty.util.ReferenceCounted;
public interface InterfaceHttpData extends Comparable<InterfaceHttpData>, ReferenceCounted
{
InterfaceHttpData retain();
InterfaceHttpData retain(int p0);
InterfaceHttpData touch();
InterfaceHttpData touch(Object p0);
InterfaceHttpData.HttpDataType getHttpDataType();
String getName();
static public enum HttpDataType
{
Attribute, FileUpload, InternalAttribute;
private HttpDataType() {}
}
}

24
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/multipart/InterfaceHttpPostRequestDecoder.java generated Normal file
View File

@@ -0,0 +1,24 @@
// Generated automatically from io.netty.handler.codec.http.multipart.InterfaceHttpPostRequestDecoder for testing purposes
package io.netty.handler.codec.http.multipart;
import io.netty.handler.codec.http.HttpContent;
import io.netty.handler.codec.http.multipart.InterfaceHttpData;
import java.util.List;
public interface InterfaceHttpPostRequestDecoder
{
InterfaceHttpData currentPartialHttpData();
InterfaceHttpData getBodyHttpData(String p0);
InterfaceHttpData next();
InterfaceHttpPostRequestDecoder offer(HttpContent p0);
List<InterfaceHttpData> getBodyHttpDatas();
List<InterfaceHttpData> getBodyHttpDatas(String p0);
boolean hasNext();
boolean isMultipart();
int getDiscardThreshold();
void cleanFiles();
void destroy();
void removeHttpDataFromClean(InterfaceHttpData p0);
void setDiscardThreshold(int p0);
}

21
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/websocketx/BinaryWebSocketFrame.java generated Normal file
View File

@@ -0,0 +1,21 @@
// Generated automatically from io.netty.handler.codec.http.websocketx.BinaryWebSocketFrame for testing purposes
package io.netty.handler.codec.http.websocketx;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
public class BinaryWebSocketFrame extends WebSocketFrame
{
public BinaryWebSocketFrame copy(){ return null; }
public BinaryWebSocketFrame duplicate(){ return null; }
public BinaryWebSocketFrame replace(ByteBuf p0){ return null; }
public BinaryWebSocketFrame retain(){ return null; }
public BinaryWebSocketFrame retain(int p0){ return null; }
public BinaryWebSocketFrame retainedDuplicate(){ return null; }
public BinaryWebSocketFrame touch(){ return null; }
public BinaryWebSocketFrame touch(Object p0){ return null; }
public BinaryWebSocketFrame(){}
public BinaryWebSocketFrame(ByteBuf p0){}
public BinaryWebSocketFrame(boolean p0, int p1, ByteBuf p2){}
}

28
java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/websocketx/CloseWebSocketFrame.java generated Normal file
View File

@@ -0,0 +1,28 @@
// Generated automatically from io.netty.handler.codec.http.websocketx.CloseWebSocketFrame for testing purposes
package io.netty.handler.codec.http.websocketx;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.http.websocketx.WebSocketCloseStatus;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
public class CloseWebSocketFrame extends WebSocketFrame
{
public CloseWebSocketFrame copy(){ return null; }
public CloseWebSocketFrame duplicate(){ return null; }
public CloseWebSocketFrame replace(ByteBuf p0){ return null; }
public CloseWebSocketFrame retain(){ return null; }
public CloseWebSocketFrame retain(int p0){ return null; }
public CloseWebSocketFrame retainedDuplicate(){ return null; }
public CloseWebSocketFrame touch(){ return null; }
public CloseWebSocketFrame touch(Object p0){ return null; }
public CloseWebSocketFrame(){}
public CloseWebSocketFrame(WebSocketCloseStatus p0){}
public CloseWebSocketFrame(WebSocketCloseStatus p0, String p1){}
public CloseWebSocketFrame(boolean p0, int p1){}
public CloseWebSocketFrame(boolean p0, int p1, ByteBuf p2){}
public CloseWebSocketFrame(boolean p0, int p1, int p2, String p3){}
public CloseWebSocketFrame(int p0, String p1){}
public String reasonText(){ return null; }
public int statusCode(){ return 0; }
}

Some files were not shown because too many files have changed in this diff Show More