KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use parseProc method of proggen Package

Best Syzkaller code snippet using proggen.parseProc

proggen.go

Source:proggen.go

...150		return ctx.genConst(a, dir, traceArg)151	case *prog.LenType:152		return syzType.DefaultArg(dir)153	case *prog.ProcType:154		return ctx.parseProc(a, dir, traceArg)155	case *prog.ResourceType:156		return ctx.genResource(a, dir, traceArg)157	case *prog.PtrType:158		return ctx.genPtr(a, dir, traceArg)159	case *prog.BufferType:160		return ctx.genBuffer(a, dir, traceArg)161	case *prog.StructType:162		return ctx.genStruct(a, dir, traceArg)163	case *prog.ArrayType:164		return ctx.genArray(a, dir, traceArg)165	case *prog.UnionType:166		return ctx.genUnionArg(a, dir, traceArg)167	case *prog.VmaType:168		return ctx.genVma(a, dir, traceArg)169	default:170		log.Fatalf("unsupported type: %#v", syzType)171	}172	return nil173}174func (ctx *context) genVma(syzType *prog.VmaType, dir prog.Dir, _ parser.IrType) prog.Arg {175	npages := uint64(1)176	if syzType.RangeBegin != 0 || syzType.RangeEnd != 0 {177		npages = syzType.RangeEnd178	}179	return prog.MakeVmaPointerArg(syzType, dir, ctx.builder.AllocateVMA(npages), npages)180}181func (ctx *context) genArray(syzType *prog.ArrayType, dir prog.Dir, traceType parser.IrType) prog.Arg {182	var args []prog.Arg183	switch a := traceType.(type) {184	case *parser.GroupType:185		for i := 0; i < len(a.Elems); i++ {186			args = append(args, ctx.genArg(syzType.Elem, dir, a.Elems[i]))187		}188	default:189		log.Fatalf("unsupported type for array: %#v", traceType)190	}191	return prog.MakeGroupArg(syzType, dir, args)192}193func (ctx *context) genStruct(syzType *prog.StructType, dir prog.Dir, traceType parser.IrType) prog.Arg {194	var args []prog.Arg195	switch a := traceType.(type) {196	case *parser.GroupType:197		j := 0198		if ret, recursed := ctx.recurseStructs(syzType, dir, a); recursed {199			return ret200		}201		for i := range syzType.Fields {202			if prog.IsPad(syzType.Fields[i].Type) {203				args = append(args, syzType.Fields[i].DefaultArg(dir))204				continue205			}206			// If the last n fields of a struct are zero or NULL, strace will occasionally omit those values207			// this creates a mismatch in the number of elements in the ir type and in208			// our descriptions. We generate default values for omitted fields209			if j >= len(a.Elems) {210				args = append(args, syzType.Fields[i].DefaultArg(dir))211			} else {212				args = append(args, ctx.genArg(syzType.Fields[i].Type, dir, a.Elems[j]))213			}214			j++215		}216	case *parser.BufferType:217		// We could have a case like the following:218		// ioctl(3, 35111, {ifr_name="\x6c\x6f", ifr_hwaddr=00:00:00:00:00:00}) = 0219		// if_hwaddr gets parsed as a BufferType but our syscall descriptions have it as a struct type220		return syzType.DefaultArg(dir)221	default:222		log.Fatalf("unsupported type for struct: %#v", a)223	}224	return prog.MakeGroupArg(syzType, dir, args)225}226// recurseStructs handles cases where syzType corresponds to struct descriptions like227// sockaddr_storage_in6 {228//        addr    sockaddr_in6229// } [size[SOCKADDR_STORAGE_SIZE], align_ptr]230// which need to be recursively generated. It returns true if we needed to recurse231// along with the generated argument and false otherwise.232func (ctx *context) recurseStructs(syzType *prog.StructType, dir prog.Dir, traceType *parser.GroupType) (prog.Arg, bool) {233	// only consider structs with one non-padded field234	numFields := 0235	for _, field := range syzType.Fields {236		if prog.IsPad(field.Type) {237			continue238		}239		numFields++240	}241	if numFields != 1 {242		return nil, false243	}244	// the strace group type needs to have more one field (a mismatch)245	if len(traceType.Elems) == 1 {246		return nil, false247	}248	// first field needs to be a struct249	switch t := syzType.Fields[0].Type.(type) {250	case *prog.StructType:251		var args []prog.Arg252		// first element and traceType should have the same number of elements253		if len(t.Fields) != len(traceType.Elems) {254			return nil, false255		}256		args = append(args, ctx.genStruct(t, dir, traceType))257		for _, field := range syzType.Fields[1:] {258			args = append(args, field.DefaultArg(dir))259		}260		return prog.MakeGroupArg(syzType, dir, args), true261	}262	return nil, false263}264func (ctx *context) genUnionArg(syzType *prog.UnionType, dir prog.Dir, straceType parser.IrType) prog.Arg {265	if straceType == nil {266		log.Logf(1, "generating union arg. straceType is nil")267		return syzType.DefaultArg(dir)268	}269	log.Logf(4, "generating union arg: %s %#v", syzType.TypeName, straceType)270	// Unions are super annoying because they sometimes need to be handled case by case271	// We might need to lookinto a matching algorithm to identify the union type that most closely272	// matches our strace type.273	switch syzType.TypeName {274	case "sockaddr_storage":275		return ctx.genSockaddrStorage(syzType, dir, straceType)276	case "sockaddr_nl":277		return ctx.genSockaddrNetlink(syzType, dir, straceType)278	case "ifr_ifru":279		return ctx.genIfrIfru(syzType, dir, straceType)280	}281	return prog.MakeUnionArg(syzType, dir, ctx.genArg(syzType.Fields[0].Type, dir, straceType), 0)282}283func (ctx *context) genBuffer(syzType *prog.BufferType, dir prog.Dir, traceType parser.IrType) prog.Arg {284	if dir == prog.DirOut {285		if !syzType.Varlen() {286			return prog.MakeOutDataArg(syzType, dir, syzType.Size())287		}288		switch a := traceType.(type) {289		case *parser.BufferType:290			return prog.MakeOutDataArg(syzType, dir, uint64(len(a.Val)))291		default:292			switch syzType.Kind {293			case prog.BufferBlobRand:294				size := rand.Intn(256)295				return prog.MakeOutDataArg(syzType, dir, uint64(size))296			case prog.BufferBlobRange:297				max := rand.Intn(int(syzType.RangeEnd) - int(syzType.RangeBegin) + 1)298				size := max + int(syzType.RangeBegin)299				return prog.MakeOutDataArg(syzType, dir, uint64(size))300			default:301				log.Fatalf("unexpected buffer type kind: %v. call %v arg %#v", syzType.Kind, ctx.currentSyzCall, traceType)302			}303		}304	}305	var bufVal []byte306	switch a := traceType.(type) {307	case *parser.BufferType:308		bufVal = []byte(a.Val)309	case parser.Constant:310		val := a.Val()311		bArr := make([]byte, 8)312		binary.LittleEndian.PutUint64(bArr, val)313		bufVal = bArr314	default:315		log.Fatalf("unsupported type for buffer: %#v", traceType)316	}317	// strace always drops the null byte for buffer types but we only need to add it back for filenames and strings318	switch syzType.Kind {319	case prog.BufferFilename, prog.BufferString:320		bufVal = append(bufVal, '\x00')321	}322	if !syzType.Varlen() {323		size := syzType.Size()324		for uint64(len(bufVal)) < size {325			bufVal = append(bufVal, 0)326		}327		bufVal = bufVal[:size]328	}329	return prog.MakeDataArg(syzType, dir, bufVal)330}331func (ctx *context) genPtr(syzType *prog.PtrType, dir prog.Dir, traceType parser.IrType) prog.Arg {332	switch a := traceType.(type) {333	case parser.Constant:334		if a.Val() == 0 {335			return prog.MakeSpecialPointerArg(syzType, dir, 0)336		}337		// Likely have a type of the form bind(3, 0xfffffffff, [3]);338		res := syzType.Elem.DefaultArg(syzType.ElemDir)339		return ctx.addr(syzType, dir, res.Size(), res)340	default:341		res := ctx.genArg(syzType.Elem, syzType.ElemDir, a)342		return ctx.addr(syzType, dir, res.Size(), res)343	}344}345func (ctx *context) genConst(syzType prog.Type, dir prog.Dir, traceType parser.IrType) prog.Arg {346	switch a := traceType.(type) {347	case parser.Constant:348		return prog.MakeConstArg(syzType, dir, a.Val())349	case *parser.GroupType:350		// Sometimes strace represents a pointer to int as [0] which gets parsed351		// as Array([0], len=1). A good example is ioctl(3, FIONBIO, [1]). We may also have an union int type that352		// is a represented as a struct in strace e.g.353		// sigev_value={sival_int=-2123636944, sival_ptr=0x7ffd816bdf30}354		// For now we choose the first option355		if len(a.Elems) == 0 {356			log.Logf(2, "parsing const type, got array type with len 0")357			return syzType.DefaultArg(dir)358		}359		return ctx.genConst(syzType, dir, a.Elems[0])360	case *parser.BufferType:361		// strace decodes some arguments as hex strings because those values are network ordered362		// e.g. sin_port or sin_addr fields of sockaddr_in.363		// network order is big endian byte order so if the len of byte array is 1, 2, 4, or 8 then364		// it is a good chance that we are decoding one of those fields. If it isn't, then most likely365		// we have an error i.e. a sockaddr_un struct passed to a connect call with an inet file descriptor366		var val uint64367		toUint64 := binary.LittleEndian.Uint64368		toUint32 := binary.LittleEndian.Uint32369		toUint16 := binary.LittleEndian.Uint16370		if syzType.Format() == prog.FormatBigEndian {371			toUint64 = binary.BigEndian.Uint64372			toUint32 = binary.BigEndian.Uint32373			toUint16 = binary.BigEndian.Uint16374		}375		switch len(a.Val) {376		case 8:377			val = toUint64([]byte(a.Val))378		case 4:379			val = uint64(toUint32([]byte(a.Val)))380		case 2:381			val = uint64(toUint16([]byte(a.Val)))382		case 1:383			val = uint64(a.Val[0])384		default:385			return syzType.DefaultArg(dir)386		}387		return prog.MakeConstArg(syzType, dir, val)388	default:389		log.Fatalf("unsupported type for const: %#v", traceType)390	}391	return nil392}393func (ctx *context) genResource(syzType *prog.ResourceType, dir prog.Dir, traceType parser.IrType) prog.Arg {394	if dir == prog.DirOut {395		log.Logf(2, "resource returned by call argument: %s", traceType.String())396		res := prog.MakeResultArg(syzType, dir, nil, syzType.Default())397		ctx.returnCache.cache(syzType, traceType, res)398		return res399	}400	switch a := traceType.(type) {401	case parser.Constant:402		val := a.Val()403		if arg := ctx.returnCache.get(syzType, traceType); arg != nil {404			res := prog.MakeResultArg(syzType, dir, arg.(*prog.ResultArg), syzType.Default())405			return res406		}407		res := prog.MakeResultArg(syzType, dir, nil, val)408		return res409	case *parser.GroupType:410		if len(a.Elems) == 1 {411			// For example: 5028  ioctl(3, SIOCSPGRP, [0])          = 0412			// last argument is a pointer to a resource. Strace will output a pointer to413			// a number x as [x].414			res := prog.MakeResultArg(syzType, dir, nil, syzType.Default())415			ctx.returnCache.cache(syzType, a.Elems[0], res)416			return res417		}418		log.Fatalf("generating resource type from GroupType with %d elements", len(a.Elems))419	default:420		log.Fatalf("unsupported type for resource: %#v", traceType)421	}422	return nil423}424func (ctx *context) parseProc(syzType *prog.ProcType, dir prog.Dir, traceType parser.IrType) prog.Arg {425	switch a := traceType.(type) {426	case parser.Constant:427		val := a.Val()428		if val >= syzType.ValuesPerProc {429			return prog.MakeConstArg(syzType, dir, syzType.ValuesPerProc-1)430		}431		return prog.MakeConstArg(syzType, dir, val)432	case *parser.BufferType:433		// Again probably an error case434		// Something like the following will trigger this435		// bind(3, {sa_family=AF_INET, sa_data="\xac"}, 3) = -1 EINVAL(Invalid argument)436		return syzType.DefaultArg(dir)437	default:438		log.Fatalf("unsupported type for proc: %#v", traceType)...

parseProc

Using AI Code Generation

1proggen p = new proggen();2p.parseProc();3proggen p = new proggen();4p.parseProc();5proggen p = new proggen();6p.parseProc();7proggen p = new proggen();8p.parseProc();9proggen p = new proggen();10p.parseProc();11proggen p = new proggen();12p.parseProc();13proggen p = new proggen();14p.parseProc();15proggen p = new proggen();16p.parseProc();17proggen p = new proggen();18p.parseProc();19proggen p = new proggen();20p.parseProc();21proggen p = new proggen();22p.parseProc();23proggen p = new proggen();24p.parseProc();25proggen p = new proggen();26p.parseProc();27proggen p = new proggen();28p.parseProc();29proggen p = new proggen();30p.parseProc();31proggen p = new proggen();32p.parseProc();

parseProc

Using AI Code Generation

1import (2func main() {3	p := proggen.ProgGen{}4	p.ParseProc()5	fmt.Println(p.ProcName)6}7import (8func ParseProc() {9	fmt.Println("Parsing the proc")10}

parseProc

Using AI Code Generation

1import (2func main() {3	p.ParseProc()4	fmt.Println("Hello, playground")5}6import (7type ProgGen struct {8}9func (p *ProgGen) ParseProc() {10	fmt.Println("ParseProc")11	b, err := ioutil.ReadFile("/Users/xxx/go/src/proc.txt")12	if err != nil {13		fmt.Print(err)14	}15	str := string(b)16	fmt.Println(str)17}18func main() {19	p.ParseProc()20}21b, err := ioutil.ReadFile("proggen/proc.txt")

parseProc

Using AI Code Generation

1import java.io.*;2import java.util.*;3import java.util.regex.*;4import java.lang.*;5import java.io.BufferedReader;6import java.io.File;7import java.io.FileReader;8import java.io.IOException;9import java.util.ArrayList;10import java.util.List;11import java.util.regex.Matcher;12import java.util.regex.Pattern;13import java.util.Scanner;14import java.util.regex.*;15{16    public static void main(String args[])throws Exception17    {18        String line;19        String str;20        String str1;21        String str2;22        String str3;23        String str4;24        String str5;25        String str6;26        String str7;27        String str8;28        String str9;29        String str10;30        String str11;31        String str12;32        String str13;33        String str14;34        String str15;35        String str16;36        String str17;37        String str18;38        String str19;39        String str20;40        String str21;41        String str22;42        String str23;43        String str24;44        String str25;45        String str26;46        String str27;47        String str28;48        String str29;49        String str30;50        String str31;51        String str32;52        String str33;53        String str34;54        String str35;55        String str36;56        String str37;57        String str38;58        String str39;59        String str40;60        String str41;61        String str42;62        String str43;63        String str44;64        String str45;65        String str46;66        String str47;67        String str48;68        String str49;69        String str50;70        String str51;71        String str52;72        String str53;73        String str54;74        String str55;75        String str56;76        String str57;77        String str58;78        String str59;79        String str60;80        String str61;81        String str62;82        String str63;83        String str64;84        String str65;85        String str66;86        String str67;87        String str68;88        String str69;89        String str70;90        String str71;91        String str72;92        String str73;93        String str74;94        String str75;95        String str76;96        String str77;97        String str78;

parseProc

Using AI Code Generation

1import (2func main() {3	p := proggen.Proggen{}4	p.ParseProc()5	fmt.Println(p.Proc)6}7import (8func main() {9	p := proggen.Proggen{}10	p.ParseProc()11	fmt.Println(p.Proc)12}13import (14func main() {15	p := proggen.Proggen{}16	p.ParseProc()17	fmt.Println(p.Proc)18}19import (20func main() {21	p := proggen.Proggen{}22	p.ParseProc()23	fmt.Println(p.Proc)24}25import (26func main() {27	p := proggen.Proggen{}28	p.ParseProc()29	fmt.Println(p.Proc)30}31import (32func main() {33	p := proggen.Proggen{}

parseProc

Using AI Code Generation

1import (2func main() {3    f, err := parse.ParseFile("test.go", nil)4    if err != nil {5        fmt.Fprintf(os.Stderr, "Error: %v6        os.Exit(1)7    }8    pretty.Println(f)9}10&ast.File{11    Decls: []ast.Decl{12        &ast.FuncDecl{13            Name: ast.Ident{14            },15            Type: &ast.FuncType{16                Params: &ast.FieldList{17                    List: []*ast.Field{18                        &ast.Field{19                            Type: &ast.Ident{20                            },21                            Names: []*ast.Ident{22                                &ast.Ident{23                                },24                            },25                        },26                    },27                },28            },29            Body: &ast.BlockStmt{30                List: []ast.Stmt{31                    &ast.ExprStmt{32                        X: &ast.CallExpr{33                            Fun: &ast.SelectorExpr{34                                X:   &ast.Ident{NamePos: 28, Name: "fmt"},35                                Sel: &ast.Ident{NamePos: 32, Name: "Println"},36                            },37                            Args: []ast.Expr{38                                &ast.BasicLit{39                                },40                            },41                        },42                    },43                },44            },45        },46    },47    Scope: &ast.Scope{48        Outer: (*ast.Scope)(nil),49        Objects: map[string]*ast.Object{50            "main": &ast.Object{51                Decl: (*ast.FuncDecl)(0xc82000e

parseProc

Using AI Code Generation

1import (2type lineInfo struct {3}4type labelInfo struct {5}6type varInfo struct {7}8type funcInfo struct {9}10type procInfo struct {11}12type proggen struct {13}14func main() {15	flag.StringVar(&procFile, "proc", "", "name of the .proc file")16	flag.StringVar(&goFile, "go", "", "name of the .go file")17	flag.Parse()18	if procFile == "" {19		fmt.Println("Please provide the .proc file")20		os.Exit(1)21	}22	if goFile == "" {23		fmt.Println("Please provide the .go file")24		os.Exit(1)25	}26	procFile, err := os.Open(proggen.procFile)27	if err != nil {28		fmt.Println("Error opening the file")29		os.Exit(1)30	}31	defer procFile.Close()32	goFile, err := os.Create(proggen.goFile)

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.